数据结构与算法——单链表

Posted 2021-04-12 五分钟学算法

点击蓝色“五分钟学算法”关注我哟

加个“星标”，一起学算法

1 数组

1.1 数组含义

数组：相同元素构成有序的元素集合。数组中存储的元素类型是一致的，数组也是学习编程时最先接触的数据集合。

1.2 存储方式

数组在内存中采用连续的存储方式，也就是说数据在内存中存放是连续的。例如：
当程序执行如下代码：

int array[10] //在栈上分配一个有10个int元素的数组

printf("array的地址:%p
",  &array);

for(int i = 0; i < 10; i++){
    printf("buf[%d]的地址:%p
", i, &array[i]);
}

输出结果：

array的地址   :00000000006ffe20

array[0]的地址:00000000006ffe20

array[1]的地址:00000000006ffe24

array[2]的地址:00000000006ffe28

array[3]的地址:00000000006ffe2c

array[4]的地址:00000000006ffe30

array[5]的地址:00000000006ffe34

array[6]的地址:00000000006ffe38

array[7]的地址:00000000006ffe3c

array[8]的地址:00000000006ffe40

array[9]的地址:00000000006ffe44

1.3 存储缺点

由于数组采用连续的存储方式，在开辟数组空间时需要保证内存有足够的连续内存才能保证内存分配。例如：当内存结构如图所示：

当程序需要内存为 1000 个数据大小的内存空间，但是由于内存中最大的连续空间为 600 ，则会导致程序分配内存失败。但是我们发现内存的使用空间为 1500 ，剩余空间仍有 1400 个数据空间，但由于这 1400 个数据空间不连续，导致创建数组失败。

2 指针

2.1 含义

int a = 0;//定义一个整型变量

int *p = &a;//创建指针变量，并将指针指向变量a

printf("a的值 = %d
", a );//输出变量值

printf("a的地址 = %p
" , &a);//输出变量地址

printf("p的内容 = %p
", p);//输出指针变量的内容

printf("通过指针访问数据a = %d
", *p);

输出结果：

a的值 = 0

a的地址 = 00000000006ffe3c

p的内容 = 00000000006ffe3c

通过指针访问数据a = 0

2.2 指针大小

指针占据的内存大小只要用函数 sizeof(指针的类型) 即可计算出。例如：在 32 位平台里，指针本身占据了 4 个字节的长度，在 64 位平台，指针占据 8 个字节大小。

测试程序：

int a = 1;

double b = 1.4f;

int *p = &a;

double *q = &b;

printf("int类型指针大小 = %d
", sizeof(p));

printf("double类型指针大小 = %d
", sizeof(q));

输出结果：

int类型指针大小 = 8

double类型指针大小 = 8

2.3 指针意义

通过指针可以将大小为N的数据分别存储至 M1、M2 和 M3 大小空间内。这种方式可以避免连续内存不足引发的内存分配失败问题。

3 数据节点

3.1 含义

数据节点是研究数据结构与算法中最为常用的术语，通常节点指的事最小的数据单元。

3.2 单链表节点

定义数据结构：

struct Node{
     int value;//数据域，以int为例
     Node * next;//指针域，指向下一个节点
 };

节点图示：

各个节点数据通过指针的方法串联起来，构成链表。由于Node中只有单向的指针next，因此构成的链表为单链表。

单链表图示：

3.3 头结点

头结点不存储实际的数据元素，用于辅助数据元素的定位，方便插入和删除操作，通常头结点标记为head。
带有头节点单链表：

4 单链表

4.1 单链表创建

创建过程：

创建程序：

//创建链表
int create_List(Node **p) {
    int data = 0;
    int ret = 0;
    Node *pHead = NULL; //头结点指针
    Node *node = NULL;
    Node *tmp = NULL;
    pHead = (Node *)malloc(sizeof(Node));//创建一个头结点
    if(pHead == NULL) {
        ret = -1;
    }
    tmp = pHead;
    printf("请输入一个整数数据
");//等待用户输入整数数据，输入-1结束
    scanf("%d", &data);
    while(data != -1) {
        node = (Node *)malloc(sizeof(Node));//创建新节点
        if(node == NULL) {
            ret = -1;
            printf("List_Create erro
");
        }
        node->data = data;//为新节点赋值
        tmp->next = node;//将当前节点添加至当前链表末尾
        tmp = node;//将当前指向的节点指针指向新节点
        printf("请输入一个整数数据
");
        scanf("%d", &data);
    }
    node->next = NULL;
    *p = pHead;
    return ret;
}

4.2 单链表遍历

单链表的遍历十分简单，只需从链表头开始，沿着指针指向顺序依次输出元素即可。
遍历过程：

遍历程序：

void traverse_List(Node* pHead) {
    Node* pCur;//创建用于遍历链表的指针
    if(pHead == NULL || pHead->next == NULL) {
        printf("LinkList is NULL
");//表为空
    }

    pCur = pHead;//将pCurrent指向头节点
    while(pCur->next) { //当前节点不为最后的节点
        printf("%d ", pCur->next->data);//输出数据值
        pCur = pCur->next;//将当前节点指针后移，指向下一个节点
    }

}

4.3 单链表查找

单链表的数据查找需要遍历整个链表，在遍历过程中，将节点数据与查找数据比较。
查找程序：

//查找数据为value的节点
Node* find_List(Node *pHead, int value){
    Node *pTmp; //遍历链表指针
    if(pHead == NULL || pHead->next == NULL) {
        printf("Node is NULL
");
        return NULL;
    }

    pTmp = pHead;
    while(pTmp->next) {//遍历链表
        printf("%d ", pTmp->next->data);
        if(pTmp->next->data == value){//判断值是否相等 
            pTmp = pTmp->next;//查找到目标节点 
            return pTmp; //返回目标节点 
        }
        pTmp = pTmp->next;//继续向下查找 
    }
    return NULL;//查找失败 
} 

4.4 单链表插入

插入过程：

插入过程

插入代码：

//p节点后插入值为i的节点
void insert_Node(Node *p, int i){
    Node* node = new Node;
    node->value = i;
    node->next = p->next;
    p->next = node;
}

4.5 单链表删除

删除过程：

删除过程

删除代码：

void delete_List(Node * pHead, int data){
   if(pHead == NULL || pHead->next == NULL) {
        printf("Node is NULL
");
        return NULL;
    }

    while(1){
        int flag=-1;
        Node* pCur;//指向当前节点的指针
        Node* pPre;//指向当前节点的上一个节点指针
        pCur = pHead->next;
        pPre= pHead;
        while(pCur){
            if(pCur->data==data){//元素比较
                //将当前节点的前驱节点的next指向当前节点的后继节点
                pPre->next = pCur->next;
                flag = 1;
                break;
            }

            //继续向后查找
            pCur = pCur->next;
            pPre = pPre->next;

        }

        if(flag==1){
            free(pCur);//释放当前节点占据空间
            printf("节点删除成功
");
        }else{
            printf("此链表找不到这个值
");
        }

    }

}

4.6 单链表逆序

单链表逆序是笔试题中出现频率较高的考点。逆序即将当前链表顺序进行反转。
逆序：

逆序过程：

逆序代码：

//单链表逆序
void reverseLinkList(Node* pHead) {
    Node* pPre = NULL;//指向当前节点的上一个节点
    Node* pCur = NULL;//指向当前节点的指针
    Node* pTmp = NULL;
    if(pHead == NULL || pHead->next == NULL || pHead->next->next == NULL) {
        return;
    }

    pPre = pHead->next;
    pCur = pHead->next->next;

    while(pCur) {//遍历整个链表
        //交换顺序，实现逆序
        pTmp = pCur->next;
        pCur->next = pPre;
        pPre = pCur;
        pCur = pTmp;
    }

    pHead->next->next = NULL;
    pHead->next = pPre;

}

5 总结

单链表优缺点：
优点：
1：插入、删除操作不需移动其他元素, 只需改变指针。
2：链表各个节点在内存中空间不要求连续，空间利用率高。
缺点：
1：访问数组元素效率低

 原 创 热 文 推 荐 

☞

你点的每个“在看”，我都认真当成了喜欢