数据结构第七周作业——双向链表&静态链表

一.双向链表

 1.代码

#include <stdio.h>
#include <malloc.h>

typedef struct DoubleLinkedNode {
    char data;
    struct DoubleLinkedNode *previous;//用于连接前面
    struct DoubleLinkedNode *next;//用于连接后面
} DLNode, *DLNodePtr;


//初始化
DLNodePtr initLinkList() {
    DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(struct DoubleLinkedNode));
    tempHeader->data = '\0';
    tempHeader->previous = NULL;
    tempHeader->next = NULL;
    return tempHeader;
}

//打印链表
void printList(DLNodePtr paraHeader) {
    DLNodePtr p = paraHeader->next;
    while(p !=NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\r\n");
}

//插入数据
void insertElement(DLNodePtr paraHeader, char paraChar, int paraPosition) {
    DLNodePtr p, q, r;

    p = paraHeader;
    int i;
    for(i = 0; i < paraPosition; i ++) {
        p = p->next;
        if(p == NULL) {
            printf("The position %d is beyond the scope of the list.", paraPosition);
            return;
        }
    }//判断插入位置是否合法

    q = (DLNodePtr)malloc(sizeof(struct DoubleLinkedNode));
    q->data = paraChar;//创建新节点

    r = p->next;
    q->next = p->next;
    q->previous = p;
    p->next = q;
    if(r != NULL) {
        r->previous = q;
    }
}

//删除某个数据
void deleteElement(DLNodePtr paraHeader, char paraChar) {
    DLNodePtr p, q, r;
    p = paraHeader;
 
    while((p->next != NULL) && (p->next->data !=paraChar)) {
        p = p->next;
    }//判断是否找到该数据，找到该数据或链表遍历完退出循环

    if(p->next == NULL) {
        printf("The char '%c' does not exist.\r\n", paraChar);
        return;
    }//未找到该数据

    q = p->next;
    r = q->next;
    p->next = r;
    if(r != NULL) {
        r->previous = p;
    }

    free(q);//释放被删除的节点 
}

void insertDeleteTest() {
    DLNodePtr tempList = initLinkList();
    printList(tempList);

    insertElement(tempList, 'H', 0);
    insertElement(tempList, 'e', 1);
    insertElement(tempList, 'l', 2);
    insertElement(tempList, 'l', 3);
    insertElement(tempList, 'o', 4);
    insertElement(tempList, '!', 5);
    printList(tempList);

    deleteElement(tempList, 'e');
    deleteElement(tempList, 'a');
    deleteElement(tempList, 'o');
    printList(tempList);

    insertElement(tempList, 'o', 1);
    printList(tempList);
}

void basicAddressTest() {
    DLNode tempNode1, tempNode2;

    tempNode1.data = 4;
    tempNode1.next = NULL;

    tempNode2.data = 6;
    tempNode2.next = NULL;

    printf("The first node: %d, %d, %d\r\n", &tempNode1, &tempNode1.data, &tempNode1.next);
    printf("The second node: %d, %d, %d\r\n", &tempNode2, &tempNode2.data, &tempNode2.next);

    tempNode1.next = &tempNode2;
}

int main() {
    insertDeleteTest();
    basicAddressTest();
}

2.运行结果

3.图示

4.心得体会

①.双向链表可以进行反向查询，在某种情况下非常便捷；

②.但因为节点结构中增加了一个指针，需要为其分配内存，占据了一定的空间，所以某种情况下会导致空间的浪费；

③.由于新加了一个指针，所以在进行插入删除操作时，操作的步骤增加，容易出错。

二.静态链表

1.代码

#include <stdio.h>
#include <malloc.h>

#define DEFAULT_SIZE 5

/*
  创建节点结构
 */
typedef struct StaticLinkedNode {
    char data;

    int next;//指向下一个数据
} *NodePtr;

/* 
  创建静态链表
 */
typedef struct StaticLinkedList {
    NodePtr nodes;

    int* used;//标记该处是否被使用
} *ListPtr;

/* 
  初始化这个静态链表
 */
ListPtr initLinkedList() {
    ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));//创建链表

    tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);//创建节点
    tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);

    tempPtr->nodes[0].data = '\0';
    tempPtr->nodes[0].next = -1;  //-1表示下一个为NULL

    tempPtr->used[0] = 1;//1表示该处空间已被使用
    int i;
    for(i = 1; i < DEFAULT_SIZE; i ++) {
        tempPtr->used[i] = 0;
    }//0表示该处空间未被使用

    return tempPtr;//返回一个静态链表
}

/* 
  打印该静态链表
 */
void printList(ListPtr paraListPtr) {
    int p = 0;
    while (p != -1) {
        printf("%c", paraListPtr->nodes[p].data);
        p = paraListPtr->nodes[p].next;
    }
    printf("\r\n");
}

/*
  插入数据
 */
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition) {
    int p, q, i;
   
    p = 0;
    for(i = 0; i <paraPosition; i ++) {
        p = paraListPtr->nodes[p].next;
        if(p == -1) {
            printf("The position %d is beyond the scope of the list.\r\n", paraPosition);
            return;
        }
    }//判断插入数据是否在越界

    for(i = 1; i < DEFAULT_SIZE; i ++) {
        if(paraListPtr->used[i] == 0) {
            printf("Space at %d allocated.\r\n", i);
            paraListPtr->used[i] = 1;
            q = i;
            break;   
        }
    }//遍历查看是否有多余的空间
    if(i == DEFAULT_SIZE) {
        printf("No space.\r\n");
        return;
    }//空间已被分配完

    paraListPtr->nodes[q].data = paraChar;

    printf("linking\r\n");
    paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
    paraListPtr->nodes[p].next = q;
}

/*
  删除数据
 */
void deleteElement(ListPtr paraListPtr, char paraChar) {
    int p, q;
    p = 0;
    while((paraListPtr->nodes[p].next !=-1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)) {
        p = paraListPtr->nodes[p].next;
    }

    if(paraListPtr->nodes[p].next == -1) {
        printf("Cannot delete %c\r\n", paraChar);
        return;
    }//判断数据是否在该静态链表上
 
    q = paraListPtr->nodes[p].next;
    paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;

    paraListPtr->used[q] = 0;//将删除数据的节点重新标记为可使用的
}

void appendInsertDeleteTest() {
    ListPtr tempList = initLinkedList();
    printList(tempList);

    insertElement(tempList, 'H', 0);
    insertElement(tempList, 'e', 1);
    insertElement(tempList, 'l', 2);
    insertElement(tempList, 'l', 3);
    insertElement(tempList, 'o', 4);
    printList(tempList);

    printf("Deleting 'e'.\r\n");
    deleteElement(tempList, 'e');
    printf("Deleting 'a'.\r\n");
    deleteElement(tempList, 'a');
    printf("Deleting 'o'.\r\n");
    deleteElement(tempList, 'o');
    printList(tempList);

    insertElement(tempList, 'x', 1);
    printList(tempList);
}

int main() {
    appendInsertDeleteTest();
}
    

2.运行结果

3.图示

​​​​​​​

4.心得体会

①.用这个可以实现部分malloc函数内容，便于清晰理解其在计算机内如何工作；

②.有些低级语言没有指针，可以用这个实现单链表的工作，避免用顺序表需要进行大量的操作；

③.这里的下标为数组下标，有些地方的下标是位序，这时候就需要进行i-1的操作处理