C语言基础——⑩③数据结构——①顺序表、单链表和双向链表

已于 2024-08-29 10:28:14 修改
阅读量651 收藏 25
点赞数 18
文章标签： 数据结构
于 2024-08-27 19:51:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82508270/article/details/141551309
版权

一、基本概念

        数据结构是一门研究如何有效组织数据，并提高数据处理效率的学科，通过研究各种数据内部的逻辑关系，使用某种特定的存储形式，并在此基础上对数据实施各种操作，这些工作被称为广义上的算法。

  • 逻辑结构：

    • 指数据之间的内在关系。通常有集合、线性表、树、图等常见的逻辑结构。

    • 逻辑结构是数据之间本身的属性，与怎么处理无关。

                

  1. 线性关系：各个元素之间是一种一对一的关系。比如书架上的书，除了首尾两本书之外，其余的任意一本书的编号假设是N，都有且仅有一个直接前驱结点和直接后继节点。
  2. 非线性关系：与上述表述不同，如果各个元素之间不是严格一对一的关系，则被称为非线性关系，比如家族中的各个成员、城市间的交通道路等，对于其中的某个元素，都可能有不止一个元素与之关联。这就是典型的非线性逻辑。

  • 存储形式：

    • 数据的存储方式。比如顺序存储、链式存储等；

    • 不同的存储形式对最终数据的处理效率通常有很大的影响（数据结构没有所谓的最优）；

    • 逻辑结构与存储形式并无必然联系。

二、算法分析【了解】

算法分析是指算法在正确的情况下，对其优劣的分析。一个好的算法通常是指：

  1. 算法对应的程序所耗时间少(eg：回文的复杂度)；
  2. 算法对应的程序所耗存储空间少(eg：数组的翻转)；
  3. 算法结构性好、易读、易移植和调试。

        数据结构与算法的本质任务，是提高程序的时间空间效率，简单讲就是让程序的执行速度越快越好，所需内存空间越少越好。虽然在很多情况下，程序的时空特性是相互制约的，就像鱼和熊掌不可兼得，但我们可以根据程序实际解决问题的侧重点，去平衡时间和空间对性能的消耗。

1、时间复杂度

        一般而言，时间复杂度并不考察一段代码运行所需要的绝对时间，因为不同的计算机的硬件参数不同，考察绝对时间没有意义。

时间复杂度一般指代码的语句执行总次数，称为语句幅度，比如：

void counting(int n)
{
    for(int i=0; i<n; i++)
   {
        printf("本行语句将会出现n次\n");
        for(int j=0; j<n; j++)
       {
            printf("本行语句将会出现n*n次\n");
       }
   }
}

在上述代码中，程序执行的语句频度理论是： 但一般情况下，我们只关心多项式的最高次幂，于是上述代码的时间复杂度我们表示为：

这意味着，该程序算法所需要的时间，与传进来的参数n的平方成正比。

不同算法的时间复杂度相差很大，如下图所示，随着所处理的问题规模的增大，不同时间复杂度的程序所需要的时间有天壤之别。

2、空间复杂度

空间复杂度的概念更简单一点，就是一段程序运行时所需的内存字节量。

3、时空复杂度互换

一段程序的性能指标，既要运行快速，又要节省内存，而通常这两者又是相互制约的，很难兼得。因此在实际解决问题时，会根据需要侧重一方，牺牲另一方。

三、线性表（一对一的存储关系）

1、概念

        对于一组拥有n个数据元素的线性表，其严格数学定义是：其中任何一个数据元素 ，有且仅有一个直接前驱 ，有且仅有一个直接后继 。首元素 无直接前驱，尾元素 无直接后继。 满足这种数学关系的一组数据，当中的数据是一个挨着一个的，常被称为一对一关系。反之，如果数据之间的关系不是一对一的，就是非线性的。

2、举例

        生活中的线性表例子非常多，比如一个班级中的以学号编排的学生，一座图书馆中的以序号编排的图书、一条正常排队等候的队列、一摞从上到下堆叠的餐盘，这些都是线性表。他们的特点都是：除了首尾两个元素，其余任何一个元素前后都对应相邻的另一个元素。

注意：

线性表是一种数据内部的逻辑关系，与存储形式无关

线性表既可以采用连续的顺序存储，也可以采用离散的链式存储

具体的实现形式是顺序表和链表。

四、顺序表

1、概念

  • 顺序表：顺序存储的线性表；
  • 链式表：链式存储的线性表，简称链表。

顺序存储就是将数据存储到一片连续的内存中，在C语言环境下，可以是具名的栈数组，或者是匿名的堆数组。

存储方式不仅仅只是提供数据的存储空间，而是必须要能体现数据之间的逻辑关系。当采用顺序存储的方式来存放数据时，唯一能用来表达数据间本身的逻辑关系的就是存储位置。比如队列中的两个人，小明和小花，如果小明在逻辑上排在相邻的小花的前面，那么在存储位置上也必须把小明存放在 相邻的小花的前面。

2、基本操作

  • 顺序表设计

        一般而言，为了方便操作顺序表，需要一个专门管理顺序表的”管理结构体“，管理结构体中一般会包含：

  1. 顺序表总容量；
  2. 顺序表当前最末元素下标位置；
  3. 顺序表指针
下面是管理结构体示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
typedef struct
{
    int   capacity; // 顺序表容量
    int   last;     // 最末元素下标
    int * data;     // 顺序表，以整型数据为例
}sequenceList;

  • 初始化

        所谓初始化就是建立一个不包含任何元素的顺序表，设置好管理结构体中的表的总容量、末元素下标，申请好顺序表内存空间等系列准备工作。

下面是初始化顺序表的示例代码：
sequenceList  *init_list(int cap)
{
    sequenceList *list = malloc(sizeof(sequenceList));
    if(list != NULL)
   {
        list -> data = malloc(sizeof(int) *cap);
        if(list -> data == NULL)
       {
            free(list);
            return NULL;
       }
        list -> capacity = cap;
        list -> last = -1;
   }
    return list;
}
测试：
int main()
{
    sequenceList *list = init_list(10);
    if(list == NULL)
   {
        perror("初始化顺序表失败!");
        exit(0);
   }
    else
   {
        printf("初始化顺序表成功！\n");
   }
}

  • 增删节点

        在顺序表中增加一个数据，可以有多种方式，比如在原数组的末尾增加，或者在原数组的头部增加，或者在数组中间任意一个位置增加。根据实际需要来定。

下面以在顺序表头部增删数据为例，示例代码如下：
// 判定顺序表是否为空
bool isEmpty(sequenceList *s)
{
    return s->last == -1;
}
// 判定顺序表是否已满
bool isFull(sequenceList *s)
{
    return s->last == s->capacity-1;
}
// 在顺序表表头插入一个新数据
bool insert(sequenceList *s, int data)
{
    if(isFull(s))
        return false;
    // 将原有数据全部往后挪一位
    for(int i=s->last; i>=0; i--)
        s->data[i+1] = s->data[i];
    
    // 将新数据置入表头
    s->data[0] = data;
    s->last++;
    return true;
}
// 将顺序表表头的数据删除掉
bool removeNode(sequenceList *s)
{
    if(isEmpty(s))
        return false;
    // 将所有数据全部往前挪一位
    for(int i=0; i<s->last; i++)
        s->data[i] = s->data[i+1];
    
    s->last--;
    return true;
}

  • 销毁顺序表

        一个顺序表最后不再需要，应当要释放其所占用的内存空间，这被称为顺序表的销毁。

下面是销毁操作的示例代码：
void destroy(sequenceList *s)
{
    if(s == NULL)
        return;
    free(s->data);
    free(s);
}

3、完整代码（顺序表的头插法）

初始化顺序表完整代码：

  • seqlist.h
    #ifndef __SEQLIST.C
#define __SEQLIST .C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h> // 导入标准bool库，可以使用true/false

// 定义顺序表的结构体
typedef struct
{
    int capacity; // 顺序表的容量（顺序表本质上是数组）
    int last;     // 末元素的下标
    int *data;    // 数据（指针变量）(其实是一个存放多个int变量的容器)
} seqList;

// 创建顺序表（顺序表的初始化）
seqList *initList(int cap);

// 向顺序表的表头插入一个新数据
bool insert(seqList *list, int data); // data是向容器（*data）中插入数据

// 判断顺序表是否满了
bool isFull(seqList *list);

// 遍历顺序表中的元素
void show(seqList *list);

// 将顺序表中指定的某个元素删除
bool removeNode(seqList *list, int data);

// 销毁顺序表
void destroy(seqList *s);
#endif
  • seqlist.c
    #include "seqlist.h"

// 初始化顺序表
seqList *initList(int cap)
{
    // 申请内存
    seqList *list = malloc(sizeof(seqList));

    // 非空校验
    if (list != NULL)
    {
        // 给数据区(整型)分配空间
        list->data = malloc(sizeof(int) * cap);

        if (list->data == NULL) // 当内存中无数据时
        {
            free(list); // 释放内存
            return NULL;
        }

        list->capacity = cap;
        list->last = -1; //
    }
}

// 判断顺序表是否满了
bool isFull(seqList *list)
{
    return list->last == list->capacity - 1; // maxIndex = capacity -1
}

// 向顺序表的表头插入一个新数据
bool insert(seqList *list, int data)
{
    // 判断顺序表是否满了
    if (isFull(list))
    {
        return false;
    }

    // 将原有数据全部往后移动一位，腾出位置给新数据
    for (int i = list->last; i >= 0; i--)
    {
        list->data[i + 1] = list->data[i];
    }

    // 将新数据置入表头
    list->data[0] = data;
    list->last++;

    return true;
}

// 遍历顺序表中的元素
void show(seqList *list)
{
    // 判断顺序表是否为空
    if (list->last == -1)
    {
        return;
    }

    // 遍历
    for (int i = 0; i <= list->last; i++)
    {
        printf("%d  ", list->data[i]);
    }

    printf("\n");
}

// 将顺序表中指定的某个元素删除
bool removeNode(seqList *list, int data)
{
    // 判断是否为空
    if (list->last == -1)
    {
        return false;
    }
    // 找到要删除的节点的位置
    int i, pos = -1;
    for (i = 0; i <= list->last; i++)
    {
        if (list->data[i] == data)
        {
            pos = i;
            break;
        }
    }

    // 找不到要删除的节点
    if (i > list->last)
    {
        return false;
    }

    // 将截止到删除目标节点之后的所有元素向前移动一位
    for (int i = pos; i < list->last; i++)
    {
        list->data[i] = list->data[i + 1];
    }
    list->last--;
    return true;
}

// 销毁顺序表
void destroy(seqList *s)
{
    if (s == NULL)
        return;

    free(s->data); // 销毁数据区
    free(s);       // 销毁外部结构体对象
}
  • seqlist_main.c
    #include "seqlist.h"

int main()
{
    // 创建顺序表
    seqList *list = initList(10);

    if (list == NULL)
    {
        perror("初始化顺序表失败！\n");
        // 结束进程
        exit(0);
    }
    else
    {
        printf("初始化顺序表成功！\n");
    }

    int n; // 接收键盘录入的整数
    printf("请输入一个整数\n");
    while (true)
    {
        scanf("%d", &n);

        // 控制循环跳出
        if (n == 0)
        {
            printf("循环已经跳出\n");
            break;
        }
        else if (n > 0)
        {
            // 插入
            if (!insert(list, n))
            {
                printf("容量已满，插入失败!\n");
                continue;
            }
        }
        else
        {
            // 删除
            if (!removeNode(list, -n))
            {
                printf("查无次数，删除失败！\n");
                continue;
            }
        }

        // 遍历顺序表
        show(list);
    }

    // 销毁
    destroy(list);
}
运行效果：

【课堂练习1】

创建一个顺序表，并从键盘接收数字输入，将输入的正整数按从小到大的顺序插入顺序表，并在输入负整数的时候将其绝对值数据删除。每次输入后，将顺序表的内容打印到屏幕上。

解析： 此题考查顺序表的基本思路，先要设计好顺序表的逻辑表达，再通过对顺序表的插入和删除操作，体会顺序存储中对于插入和删除的不便性。

参考代码：

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct
{
    int total_size; // 顺序表总容量
    int last;       // 顺序表最末元素的下标
 int *data;      // 顺序表的存储空间
}sqlist;
// 初始化一个空的顺序表
sqlist * init_list(int total_size)
{
 sqlist *sq = (sqlist *)malloc(sizeof(sqlist));
    if(sq != NULL)
   {
        sq->total_size = total_size;
        sq->last       = -1; // 用-1表征当前没有元素
        sq->data = (int *)malloc(sizeof(int) * total_size);
        if(sq->data == NULL)
       {
            free(sq);
       }
   }
 return sq;
}
// 在递增的顺序表中找到x应插入的合适位置
int get_pos(sqlist *sq, int x)
{
 int pos = 0;
 while((pos<=sq->last) && (sq->data[pos]<x))
 pos++;
    // 当链表为空（即sq->last为-1时），返回0
 return pos;
}
// 判断顺序表是否已满
bool is_full(sqlist *sq)
{
    return sq->last >= sq->total_size-1;
}
// 将元素x插入顺序表sq中
bool insert(sqlist *sq, int x)
{
    if(is_full(sq))
        return false;
    // 在顺序表中得到即将要插入的元素x的合适的位置
 int pos = get_pos(sq, x);
    // 将顺序表中pos往后的所有元素往后挪一位
 for(int i=sq->last; i>=pos; i--)
 sq->data[i+1] = sq->data[i];
 sq->data[pos] = x;
 sq->last++;
 return true;
}
// 在顺序表sq中，定位元素x
int locate(sqlist *sq, int x)
{
 int pos;
 for(pos=0; pos<=sq->last; pos++)
   {
 if(sq->data[pos] == x)
       {
 printf("data[%d]=%d\n", pos, x);
 return pos;
 }
 }
 return -1;
}
// 从顺序表中将元素x剔除
bool delete(sqlist *sq, int x)
{
 int pos;
 pos = locate(sq, x);
    // 元素x不存在
    if(pos == -1)
        return false;
    // 将pos后续的元素全部往前挪一位
 for(; pos<=sq->last; pos++)
 sq->data[pos] = sq->data[pos+1];
 sq->last--;
 return true;
}
// 展示顺序表元素
void show_data(sqlist *sq)
{
 for(int i=0; i<=sq->last; i++)
 printf("\tsq->data[%d]=%d\n", i, sq->data[i]);
 printf("=======================\n");
}
int main(int argc, char *argv[])
{
    // 初始化一条空的顺序表
 sqlist *sq = init_list(10);
    // 插入元素
    int num;
    while(1)
   {
        scanf("%d", &num);
        if(num > 0)
       {
            if(insert(sq, num))
        show_data(sq);
            else
                fprintf(stderr, "顺序表已满\n");
       }
        else if(num < 0)
       {
            if(delete(sq, -num))
        show_data(sq);
            else
                fprintf(stderr, "元素不存在\n");
       }
        else
       {
            fprintf(stderr, "BYE\n");
            break;
       }
   }
 return 0;
}

4、顺序表优缺点总结

顺序存储中，由于逻辑关系是用物理位置来表达的，因此从上述示例代码可以很清楚看到，增删数据 都非常困难，需要成片地移动数据。顺序表对数据节点的增删操作是很不友好的。

总结其特点如下：

  • 优点
  1. 不需要多余的信息来记录数据间的关系，存储密度高；
  2. 所有数据顺序存储在一片连续的内存中，支持立即访问任意一个随机数据，比如上述顺序表中第 个节点是 s->data[i]。
  • 缺点
  1. 插入、删除时需要保持数据的物理位置反映其逻辑关系，一般需要成片移动数据；
  2. 当数据节点数量较多时，需要一整片较大的连续内存空间；
  3. 当数据节点数量变化剧烈时，内存的释放和分配不灵活。

五、单链表

1、基本概念

  • 顺序表：顺序存储的线性表；

  • 链式表：链式存储的线性表，简称链表。

既然顺序存储中的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后在用来指针将它们串起来。这种朴素的思路所形成的链式线性表，就是所谓的链表。

顺序表和链表在内存在的基本样态如下图所示：

2、链表的分类

根据链表中各个节点之间使用指针的个数，以及首尾节点是否相连，可以将链表细分为如下种类：

  1. 单向链表；
  2. 单向循环链表；
  3. 双向循环链表。

这些不同链表的操作都是差不多的，只是指针数目的异同。以最简单的单向链表为例，其基本示意图 如下所示：

上图中，所有的节点均保存一个指针，指向其逻辑上相邻的下一个节点（末尾节点指向空）。另外注 意到，整条链表用一个所谓的头指针 head 来指向，由 head 开始可以找到链表中的任意一个节点。 head 通常被称为头指针。

链表的基本操作，一般包括：

  1. 节点设计；
  2. 初始化空链表；
  3. 增删节点；
  4. 链表遍历；
  5. 销毁链表。

3、单链表节点设计

单向链表的节点非常简单，节点中除了要保存用户数据之外（这里以整型数据为例），只需要增加一 个指向本类节点的指针即可，如下所示：

typedef int DATA;
typedef struct Node
{
 DATA data;    // 存储数据---数据域
 struct Node *next;  // 存储下一个节点的地址---指针域
} NODE;

4、单链表初始化

首先，空链表有两种常见的形式。一种是带所谓的头结点的，一种是不带头结点的。所谓的头结点是不存放有效数据的节点，仅仅用来方便操作，如下：

而不带头结点的空链表如下所示：

注意：

  • 头指针 head 是必须的，是链表的入口；
  • 头节点是可选的，为了方便某些操作。

由于头结点是不存放有效数据的，因此如果空链表中带有头结点，那么头指针 head 将永远不变，这会 给以后的链表操作带来些许便捷。

示例代码：

/*
@function:   int slist_create(NODE** head,DATA data);
@berif:     创建单项链表
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_create(NODE** head,DATA data)
{
    NODE* p  = (NODE*)malloc(sizeof(NODE));
    if(!p)
   {
         return -1;
   }
    p -> data = data;
    p -> next = NULL;
    *head = p;
    return 0;
}

5、单链表增删节点

相对于顺序表需要整片移动数据，链表增删节点只需要修改几个相关指针的指向，动作非常快速。 与顺序表类似，可以对一条链表中的任意节点进行增删操作。

示例代码是：

/*
@function:   int slist_addHead(NODE** head,DATA data);
@berif:     向链表头部插入一个节点数据
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_addHead(NODE** head,DATA data)
{
    NODE* p = (NODE*)malloc(sizeof(NODE));
    if(!p)
   {
      return -1;
   }
    p -> data = data;
    p -> next = *head;
    *head     = p;
    return 0;   
}
/*
@function:   int slist_addTail(NODE** head,DATA data);
@berif:     向链表尾部插入一个节点数据
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_addTail(NODE** head,DATA data)
{
    NODE * pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
   {
        return -1;
   }
    pNew -> data = data;
    pNew -> next = NULL;
    NODE* p = *head, *q = NULL;
    if(!p)
   {
        *head = pNew;
        return 0;    
   }
    while(p)
   {
        q  = p;
        p  = p -> next;
   }
    q -> next = pNew;
    
    return 0;
}
/*
@function:   int slist_insert(NODE** head,DATA pos ,DATA data);
@berif:     向链表节点值为pos的位置插入一个节点数据data
@argument:   head: 指向头指针变量的地址
             pos: 插入节点位置的节点数据
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{
    // 创建一个新节点
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return  -1;
    // 给新节点赋值
    pNew -> data = data;
    pNew -> next = NULL;
    NODE *p = *head, *q = NULL;
    if(!p)
   {
        *head = pNew;
        return 0;
   }
    // 等值判断
    if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
   {
        pNew -> next = *head;
        *head = pNew;
        return 0;
   }
    while(p)
   {
         // 从头开始，找到pos指定位置的节点
         if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
         {
               // 新节点指向pos位置对应的节点（pos对应节点位置在新节点之后）
               pNew -> next = p;
               // q节点指向新节点（新节点前一个节点）
               q -> next = pNew;
               return 0;
         }
         // pos对应位置的节点指向新节点，新节点在pos对应节点的后面
         q  = p;
         p  = p -> next;
   }
    // 
    q -> next = pNew;
    return 0;
}
/*
@function:   int slist_update(const NODE* head,DATA old,DATA newdata);
@berif:     更新链表数据old 为 newdata
@argument:   head: 指向头指针变量
             old: 待更新的节点数据
             newdata: 更新后的节点数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_update(const NODE* head,DATA old,DATA newdata)
{
     NODE* p = NULL;
     if(!(p = slist_find(head,old)))
         return -1;
     p -> data = newdata;
     return 0;
}

/*
@function:   int slist_delete(NODE** head,DATA data);
@berif:     删除链表中节点值为data的节点
@argument:   head: 指向头指针变量的地址
             data: 删除节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{
    NODE *p = *head, *q = NULL;
    if(!p)
      return -1;
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
   {
        *head = p -> next;
        free(p);
        return 0;
   }
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
              q -> next = p -> next;
              free(p);
              return 0;
         }
         q  = p;
         p  = p -> next;
   }
    return -1;
}

注意：

删除链表的节点并不意味着释放其内存，而是将其剔除出链表。

6、单链表的遍历

遍历的意思就是逐个访问每一个节点，对于线性表而言，由于路径唯一的选择就是从头走到尾。因此 相当而言比较简单。

下面是单向链表的遍历示例代码，假设遍历每个节点并将其整数数据输出：

/*
@function:   NODE* slist_find(const NODE* head,DATA data);
@berif:     查找链表数据data
@argument:   head: 指向头指针变量
             data: 待查找的数据
@return :   成功返回节点的地址
             失败返回NULL
*/
NODE* slist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
             return (NODE*)p;
         }
         p = p -> next;
   }
    return NULL;
}
/*
@function:   void slist_showAll(const NODE* head);
@berif:     遍历链表数据
@argument:   head: 指向头指针变量
@return :   无
*/
void slist_showAll(const NODE* head)
{
     const NODE*  p  = head;
    
     while(p)
     {
          printf("%d ",p -> data);
          p = p -> next;
     }
     printf("\n");
}

7、单链表的销毁(堆中的内存需手动回收)

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释放每一个节点。

注意：

销毁链表时，遍历节点要注意不能弄丢相邻节点的指针。

示例代码如下：

/*
@function:   void slist_destroy(NODE** head);
@berif:     回收链表
@argument:   head: 指向头指针变量的地址
@return :   无
*/
void slist_destroy(NODE** head)
{
   NODE* p = *head, *q = NULL;
   
   while(p)
   {
        q = p;
        p = p -> next;
        free(q);
   }
   *head = NULL;
}

注意：我们可以使用valgrind进行内存检测，举例：

valgrind ./..

8、完整代码（单链表的尾插法）

  • singleList.h

    #ifndef __SINGLELIST_H
#define __SINGLELIST_H
// 头文件
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
typedef  int   DATA; 
typedef struct node
{
    DATA          data;
    struct node  *next;
}NODE;
// 链表创建
int slist_create(NODE**,DATA);
// 链表数据添加-头插法
int slist_addHead(NODE** head,DATA data);
// 链表数据添加-尾插法
int slist_addTail(NODE** head,DATA data);
// 链表数据添加-中间插法
int slist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* slist_find(const NODE* head,DATA data);
// 链表数据更新
int slist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void slist_showAll(const NODE* head);
// 链表数据删除
int slist_delete(NODE** head,DATA data);
// 链表回收
void slist_destroy(NODE** head);
#endif

  • singleList.c

    #include "singleList.h"
/*
@function:   int slist_create(NODE** head,DATA data);
@berif:     创建单项链表
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_create(NODE** head,DATA data)
{
    NODE* p  = (NODE*)malloc(sizeof(NODE));
    if(!p)
   {
         return -1;
   }
    p -> data = data;
    p -> next = NULL;
    *head = p;
    return 0;
}
/*
@function:   int slist_addHead(NODE** head,DATA data);
@berif:     向链表头部插入一个节点数据
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_addHead(NODE** head,DATA data)
{
    NODE* p = (NODE*)malloc(sizeof(NODE));
    if(!p)
   {
      return -1;
   }
    p -> data = data;
    p -> next = *head;
    *head     = p;
    return 0;   
}
/*
@function:   int slist_addTail(NODE** head,DATA data);
@berif:     向链表尾部插入一个节点数据
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_addTail(NODE** head,DATA data)
{
    NODE * pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
   {
        return -1;
   }
    pNew -> data = data;
    pNew -> next = NULL;
    NODE* p = *head, *q = NULL;
    if(!p)
   {
        *head = pNew;
        return 0;    
   }
    while(p)
   {
        q  = p;
        p  = p -> next;
   }
    q -> next = pNew;
    
    return 0;
}
/*
@function:   int slist_insert(NODE** head,DATA pos ,DATA data);
@berif:     向链表节点值为pos的位置插入一个节点数据data
@argument:   head: 指向头指针变量的地址
             pos: 插入节点位置的节点数据
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return  -1;
    pNew -> data = data;
    pNew -> next = NULL;
    NODE *p = *head, *q = NULL;
    if(!p)
   {
        *head = pNew;
        return 0;
   }
    if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
   {
        pNew -> next = *head;
        *head = pNew;
        return 0;
   }
    while(p)
   {
         if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
         {
               pNew -> next = p;
               q -> next = pNew;
               return 0;
         }
         q  = p;
         p  = p -> next;
   }
    q -> next = pNew;
    return 0;
}
/*
@function:   NODE* slist_find(const NODE* head,DATA data);
@berif:     查找链表数据data
@argument:   head: 指向头指针变量
             data: 待查找的数据
@return :   成功返回节点的地址
             失败返回NULL
*/
NODE* slist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
             return (NODE*)p;
         }
         p = p -> next;
   }
    return NULL;
}
/*
@function:   int slist_update(const NODE* head,DATA old,DATA newdata);
@berif:     更新链表数据old 为 newdata
@argument:   head: 指向头指针变量
             old: 待更新的节点数据
             newdata: 更新后的节点数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_update(const NODE* head,DATA old,DATA newdata)
{
     NODE* p = NULL;
     if(!(p = slist_find(head,old)))
         return -1;
     p -> data = newdata;
     return 0;
}
/*
@function:   void slist_showAll(const NODE* head);
@berif:     遍历链表数据
@argument:   head: 指向头指针变量
@return :   无
*/
void slist_showAll(const NODE* head)
{
     const NODE*  p  = head;
    
     while(p)
     {
          printf("%d ",p -> data);
          p = p -> next;
     }
     printf("\n");
}
/*
@function:   int slist_delete(NODE** head,DATA data);
@berif:     删除链表中节点值为data的节点
@argument:   head: 指向头指针变量的地址
             data: 删除节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{
    NODE *p = *head, *q = NULL;
    if(!p)
      return -1;
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
   {
        *head = p -> next;
        free(p);
        return 0;
   }
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
              q -> next = p -> next;
              free(p);
              return 0;
         }
         q  = p;
         p  = p -> next;
   }
    return -1;
}
/*
@function:   void slist_destroy(NODE** head);
@berif:     回收链表
@argument:   head: 指向头指针变量的地址
@return :   无
*/
void slist_destroy(NODE** head)
{
   NODE* p = *head, *q = NULL;
   
   while(p)
   {
        q = p;
        p = p -> next;
        free(q);
   }
   *head = NULL;
}

  • main.c

    #include "singleList.h"
int main(void)
{
    NODE*  head = NULL;
    if(slist_create(&head,888) < 0) 
   {
        puts("create failed");
 return -1;
   }
    slist_addTail(&head,999);    
    slist_addTail(&head,222);    
    slist_addTail(&head,666);    
    slist_addTail(&head,777);    
    
    slist_addHead(&head,555);
    
    slist_insert(&head,888,1024);
    slist_showAll(head);
    
    DATA   data ;
    while(0)
   {
  #ifdef DELETE
       printf("请输入要删除的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;       
       if(slist_delete(&head,data) < 0)
       {
           puts("删除失败,请重试");
           continue;
       }
       slist_showAll(head);
  #else
       NODE *pFind = NULL;
       DATA newdata = 512;
       printf("请输入要查找的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;
      // if(!(pFind = slist_find(head,data)))
       if(slist_update(head,data,newdata) == -1)
       {
           puts("查找的数据不存在,请重试");
           continue;
       }
       //printf("查找数据:%d 内存地址:%p\n",pFind -> data, &(pFind -> data));
       slist_showAll(head);
  #endif
   }
    slist_destroy(&head);
    puts("====销毁后====="); 
    slist_showAll(head);
    return 0;
}

【课堂练习2】

创建一个单向表，并从键盘接收数字输入，将输入的正整数按从小到大的顺序插入链表，并在输入负 整数的时候将其绝对值数据删除。每次输入后，将链表的内容打印到屏幕上。

解析： 此题考查单链表的基本思路，体会链式存储中对于插入和删除的便利性。

参考代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct node
{
 int num;
 struct node *next;
}listnode, *linklist;
bool init_list(linklist *phead)
{
 *phead = (linklist)malloc(sizeof(listnode));
 if(*phead == NULL)
 return false;
 (*phead)->next = NULL;
 return true;
}
bool is_empty(linklist head)
{
 return (head->next == NULL);
}
bool insert(linklist head, int x)
{
 linklist new = (linklist)malloc(sizeof(listnode));
 if(new == NULL){
 perror("malloc failed");
 return false;
 }
 new->num = x;
 /********************************
   the single linklist IS empty
 *********************************/
 if(is_empty(head)){
 head->next = new;
 new->next = NULL;
 }
 /*********************************
 the single linklist is NOT empty
 **********************************/
 else{
 linklist p, q;
 p = head;
 q = p->next;
 while(q != NULL){
 if(q->num < x){
 q = q->next;
 p = p->next;
 continue;
 }
 break;
 }
 new->next = q;
 p->next = new;
 }
 return true;
}
bool delete(linklist head, int x)
{
 if(is_empty(head))
 return false;
 linklist p, q;
 p = head;
 q = p->next;
 while(q != NULL){
 if(q->num != x){
 p = p->next;
 q = q->next;
 continue;
 }
 p->next = q->next;
 free(q);
 return true;
 }
 return false;
}
void show(linklist head)
{
 if(is_empty(head))
 return;
 linklist p = head->next;
 while(p != NULL && p->next != NULL){
 printf("%d-->", p->num);
 p = p->next;
 }
 printf("%d\n", p->num);
}
int main(void)
{
 linklist head;
 init_list(&head);
 int tmp, ret;
 while(1){
 ret = scanf("%d", &tmp);
 if(ret != 1)
 exit(0);
 if(tmp >= 0){
 if(!insert(head, tmp))
 fprintf(stderr, "insertion falied!\n");
 else
 show(head);
 }
 else{
 if(!delete(head, -tmp))
 fprintf(stderr, "%d does NOT exist!\n", -tmp);
 else
 show(head);
 }
 }
 fprintf(stderr, "Bye-Bye!\n");
 return 0;
}

10、链表优缺点

链式存储中，所有节点的存储位置是随机的，他们之间的逻辑关系用指针来确定，跟物理存储位置无 关，因此从上述示例代码可以很清楚看到，增删数据都非常迅速，不需要移动任何数据。另外，又由 于位置与逻辑关系无关，因此也无法直接访问某一个指定的节点，只能从头到尾按遍历的方式一个个 找到想要的节点。

简单讲，链式存储的优缺点跟顺序存储几乎是相对的。

总结其特点如下：

  • 优点：
  1. 插入、删除时只需要调整几个指针，无需移动任何数据；
  2. 当数据节点数量较多时，无需一整片较大的连续内存空间，可以灵活利用离散的内存；
  3. 当数据节点数量变化剧烈时，内存的释放和分配灵活，速度快。
  • 缺点：
  1. 在节点中，需要多余的指针来记录节点之间的关联；
  2. 所有数据都是随机存储的，不支持立即访问任意一个随机数据。

11、循环单向链表【扩展】

所谓的循环，指得是将链表末尾节点循环地指向链表表头。比如，单向链表变成循环链表的示意图如下所示：

循环链表的操作跟普通链表操作基本上是一致的，只要针对循环特性稍作修改即可。比如：

完整代码（循环没有头插尾插，只有中间插法）：

  • sclist.h 
    #ifndef __SCLIST_H
#define __SCLIST_H
typedef  int   DATA; 
typedef struct node
{
    DATA          data;
    struct node  *next;
}NODE;
int sclist_create(NODE**,DATA);
int sclist_insert(NODE** head,DATA data);
NODE* sclist_find(const NODE* head,DATA data);
int sclist_update(const NODE* head,DATA old,DATA newdata);
void sclist_showAll(const NODE* head);
int sclist_delete(NODE** head,DATA data);
void sclist_destroy(NODE** head);
#endif
  • sclist.c 
    #include "sclist.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
@function:   int sclist_create(NODE** head,DATA data);
@berif:     创建单项链表
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int sclist_create(NODE** head,DATA data)
{
    if(*head)
       return -1;
    NODE* p  = (NODE*)malloc(sizeof(NODE));
    if(!p)
   {
         return -1;
   }
    p -> data = data;
    p -> next = p;
    *head = p;
    return 0;
}
NODE* sclist_findtail(const NODE* head)
{
    const NODE* p = head, *q = NULL;
    while(p)
   {
        q = p;
        p = p -> next;
        if(p == head)
            break;
   } 
    return (NODE*)q;
}
/*
@function:   int sclist_insert(NODE** head,DATA data);
@berif:     向链表节点值为pos的位置插入一个节点数据data
@argument:   head: 指向头指针变量的地址
             data: 存储在新节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int sclist_insert(NODE** head,DATA data)
{
    NODE* tail = sclist_findtail(*head);    
    if(!tail)
      return sclist_create(head,data);           
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return  -1;
    pNew -> data = data;
    pNew -> next = *head;
    tail -> next = pNew;
//   *head = pNew;
    return 0;
}
/*
@function:   NODE* sclist_find(const NODE* head,DATA data);
@berif:     查找链表数据data
@argument:   head: 指向头指针变量
             data: 待查找的数据
@return :   成功返回节点的地址
             失败返回NULL
*/
NODE* sclist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
             return (NODE*)p;
         }
         p = p -> next;
         if(p == head)
            break;
   }
    return NULL;
}
/*
@function:   int sclist_update(const NODE* head,DATA old,DATA newdata);
@berif:     更新链表数据old 为 newdata
@argument:   head: 指向头指针变量
             old: 待更新的节点数据
             newdata: 更新后的节点数据
@return :   成功返回 0
             失败返回 -1
*/
int sclist_update(const NODE* head,DATA old,DATA newdata)
{
     NODE* p = NULL;
     if(!(p = sclist_find(head,old)))
         return -1;
     p -> data = newdata;
     return 0;
}
/*
@function:   void sclist_showAll(const NODE* head);
@berif:     遍历链表数据
@argument:   head: 指向头指针变量
@return :   无
*/
void sclist_showAll(const NODE* head)
{
     const NODE*  p  = head;
    
     while(p)
     {
          printf("%d ",p -> data);
          p = p -> next;
          if(p == head)
             break; 
     }
     printf("\n");
}
/*
@function:   int sclist_delete(NODE** head,DATA data);
@berif:     删除链表中节点值为data的节点
@argument:   head: 指向头指针变量的地址
             data: 删除节点中的数据
@return :   成功返回 0
             失败返回 -1
*/
int sclist_delete(NODE** head,DATA data)
{
    NODE *p = *head, *q = NULL;
    if(!p)
      return -1;
   
    NODE* tail = sclist_findtail(*head);
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
   {
        if(*head == tail)
       {
            *head = NULL;
            free(p);
            return 0;
       }
        tail -> next = (*head) -> next;
        *head = p -> next;
        free(p);
        return 0;
   }
    while(p)
   {
         if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
         {
              q -> next = p -> next;
              free(p);
              return 0;
         }
         q  = p;
         p  = p -> next;
         if(p == *head)
            break;
   }
    return -1;
}
/*
@function:   void sclist_destroy(NODE** head);
@berif:     回收链表
@argument:   head: 指向头指针变量的地址
@return :   无
*/
void sclist_destroy(NODE** head)
{
   NODE* tail = sclist_findtail(*head);
   if(!tail)
   {
       return ;
   }
   tail -> next = NULL;    //将单向循环链表拆成单向链表
   
   NODE* p = *head, *q = NULL;
   
   while(p)
   {
        q = p;
        p = p -> next;
        free(q);
   }
   *head = NULL;
}
  • sclist_main.c 
    #include <stdio.h>
#include <stdlib.h>
#include "sclist.h"
#define DELETE  
extern int play_game(NODE** head,DATA num);
int main(int argc,char** argv)
{
    NODE*  head = NULL;
    if(sclist_create(&head,888) < 0) 
   {
        puts("create failed");
 return -1;
   }
    sclist_insert(&head,999);    
    sclist_insert(&head,222);    
    sclist_insert(&head,666);    
    sclist_insert(&head,777);    
    sclist_showAll(head);
    
    DATA   data ;
    while(0)
   {
  #ifdef DELETE
       printf("请输入要删除的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;       
       if(sclist_delete(&head,data) < 0)
       {
           puts("删除失败,请重试");
           continue;
       }
       sclist_showAll(head);
  #else
       NODE *pFind = NULL;
       DATA newdata = 512;
       printf("请输入要查找的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;
      // if(!(pFind = slist_find(head,data)))
       if(slist_update(head,data,newdata) == -1)
       {
           puts("查找的数据不存在,请重试");
           continue;
       }
       //printf("查找数据:%d 内存地址:%p\n",pFind -> data, &(pFind -> data));
       slist_showAll(head);
  #endif
   }
    sclist_destroy(&head);
    puts("====销毁后====="); 
    sclist_showAll(head);
    
    puts("====PlayGame====="); 
    
    NODE*  pHead = NULL;
    for(int i = 1; i <= atoi(argv[1]); i++)
       sclist_insert(&pHead,i);
    sclist_showAll(pHead);
    DATA last = play_game(&pHead,5);
    printf("最后一个元素:%d\n",last);
    sclist_destroy(&pHead);
    puts("====销毁后====="); 
    sclist_showAll(pHead);
    return 0;
}

常见问题：

【1】需不需要买数据结构的书？

答：可以买，但不需要。我们不需要通篇掌握数据结构的所有内容，而只需要掌握其中核心的重要概 念即可。

【2】数据结构的内容在哪里会用到？

答：只要是做编程开发，基本都要涉及数据结构与算法。但也无需忧虑，很多数据结构的基础算法， 比如哈希表、二叉树、各种排序等，都是很多现成的系统模块内置的，一般情况下不需要去重新编写 它们，但需要清楚这些基本概念的由来，以及他们的适用场景和异同。另外像链表、栈和队列等，则 是最基本要掌握的内容，不管是底层开发，还是应用层开发，不管是简单的程序还是复杂的项目，基 本都要用到这些小工具。

【3】 面试题： 对于一个具有n和节点的单向链表(n > 100)， 只通过一次遍历找到倒数第 50个节点

提示： 借助于 2个指针，一个在前，一个在后。

思路： 先让前一个指针遍历到第50个节点的位置，然后后一个指针，再跟随前一个指针一起向后移 动，当前一个指针遍历完所有节点，后一个指针就是指向了倒数第50个节点的位置。

六、双向链表

1、概念

对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因 此，双向循环链表，是在实际运用中是最常见的链表形态。

2、基本操作

与普通的链表完全一致，双向循环链表虽然指针较多，但逻辑是完全一样。基本的操作包括：

  1. 节点设计；
  2. 初始化空链表；
  3. 增删节点；
  4. 链表遍历；
  5. 销毁链表

3、节点设计

双向链表的节点只是比单向链表多了一个前向指针。

示例代码如下所示：

typedef  int   DATA; 
typedef struct node
{
    // 以整型数据为例
    DATA          data;
    // 指向相邻的节点的双向指针
    struct node  *prev;
    struct node  *next;
}NODE;

4、初始化

所谓初始化，就是构建一条不含有效节点的空链表。 以带头结点的双向循环链表为例，初始化后，其状态如下图所示：

在初始空链表的情况下，链表只有一个头结点。

下面是初始化示例代码：

int dlist_create(NODE** head,DATA data)
{
    // 创建新节点（申请内存空间）
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    // 给节点赋初值
    pNew -> data = data;
    // 前后指针默认都指向NULL
    pNew -> prev = pNew -> next = NULL;
    // 将新节点作为头节点
    *head = pNew;
    return 0;
}

5、插入节点

与单链表类似，也可以对双链表中的任意节点进行增删操作，常见的有所谓的头插法、尾插法等， 即：将新节点插入到链表的首部或者尾部。

示例代码是：

  • 头插法：将新节点插入到链表的头部
    // 将新节点pNew，插入到链表的首部
int dlist_addHead(NODE** head,DATA data)
{
    // 创建新节点并申请内存
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1; 
    // 给新节点赋值
    pNew -> data = data;
    pNew -> prev = NULL;
    // 后针指向头指针
    pNew -> next = *head;
   
    // 如果头指针存在
    if(*head)
      // 头指针的前指针指向新节点
     (*head) -> prev = pNew;
    
    // 新插入的节点作为新的头节点
    *head = pNew;
    return 0;
}
  • 尾插法：将新节点插入到链表的尾部
    // 将新节点pNew，插入到链表的尾部
int dlist_addTail(NODE** head,DATA data)
{
    // 创建节点并申请内存
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
        return -1;
    // 初始化节点
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = NULL;
    // 用来记录尾节点，默认头节点就是尾节点
    NODE* p = *head;
    if(!p)
   {
        // 头节点不存在，新插入的节点作为头节点
        *head = pNew;
        return 0;
   }
    // 通过循环，查找尾节点
    while(p -> next)
   {
        p  = p -> next;
   }
    // 尾节点的后指针指向新插入的节点
    p -> next    = pNew;
    // 新插入的节点的前指针指向尾节点
    pNew -> prev = p;
    
    // 此时的新节点作为了新的尾节点
    
    return 0;
}
  • 中间插法：将新节点插入到链表的指定位置
    // 将新节点pNew，插入到链表的指定位置
int dlist_insert(NODE** head,DATA pos,DATA data)
{
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = NULL;
    NODE* p = *head, *q = NULL;
    if(!p)
   {
         *head = pNew;
         return 0;
   }
    if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
   {
         pNew -> next = p;
         p -> prev    = pNew;
         *head        = pNew;
         return 0;
   } 
    while(p)
   {
        if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
       {
            pNew -> next  = p;
            pNew -> prev  = q;
            p    -> prev  = pNew;
            q    -> next  = pNew;
            return 0;
       } 
         q = p;
         p = p -> next;
   }
    q -> next = pNew;
    pNew -> prev = q;
   
    return 0;
}

6、删除节点

注意，从链表中将一个节点剔除出去，并不意味着要释放节点的内容。当然，我们经常在剔除了一个 节点之后，紧接着的动作往往是释放它，但是将“剔除”与“释放”两个动作分开，是最基本的函数封装的 原则，因为它们虽然常常连在一起使用，但它们之间并无必然联系，例如：当我们要移动一个节点的 时候，实质上就是将“剔除”和“插入”的动作连起来，此时就不能释放该节点了。

在双向链表中剔除指定节点的示例代码如下：

// 将data对应的节点从链表中剔除
int dlist_delete(NODE** head,DATA data)
{
    NODE* p = *head;
    if(!p)
      return -1;
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
   {
         if(p -> next == NULL)
         {
              *head = NULL;
              free(p);
              return 0;
         }
         *head        = p -> next;
         p -> next -> prev = NULL;
         free(p);
         return 0;
   }
    
    while(p)
   {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
       {
             p -> prev -> next  =  p -> next;
             if(p -> next == NULL)
                  p -> prev -> next  = NULL;
             else
                  p -> next -> prev  = p -> prev;
             free(p) ;
             return 0;
       }
         p  = p -> next;
   }
    return -1;
}

7、链表的遍历

对于双向循环链表，路径可以是向后遍历，也可以向前遍历。

下面是根据指定数据查找节点，向前、向后遍历的示例代码，假设遍历每个节点并将其整数数据输出：

// 根据指定数据查找节点
NODE* dlist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    
    while(p)
   {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
            return (NODE*)p;
        p  = p -> next;
   } 
    return NULL;
}
// 向前|向后遍历
void dlist_showAll(const NODE* head)
{
    const NODE* p = head;
    while(p)
   {
        printf("%d ",p -> data);
        p = p -> next;// 向后遍历
        // p = p -> prev;// 向前遍历
   }
    printf("\n");
}

8、修改链表

我们也可以针对链表中的数据进行修改，只需要提供一个修改的源数据和目标数据即可。

示例代码如下：

int dlist_update(const NODE* head,DATA old,DATA newdata)
{
    NODE* pFind = NULL;
    if(pFind = dlist_find(head,old))
   {
        pFind -> data = newdata;
        return 0;
   } 
    return -1;
}

9、销毁链表

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释放每一个节点。

注意： 销毁链表时，遍历节点要注意不能弄丢相邻节点的指针

示例代码如下：

void dlist_destroy(NODE** head)
{
   NODE *p = *head, *q = NULL;
   
   while(p)
   {
        q = p;
        p = p -> next;
        free(q);
   }
   *head = NULL;
}

10、完整代码（双链表的头插法、尾插法和中间插法）

删除节点

  • dlist.h

    #ifndef __DLIST_H
#define __DLIST_H
typedef  int   DATA; 
typedef struct node
{
    DATA          data;
    struct node  *prev;// 前驱指针
    struct node  *next;// 后继指针
}NODE;
// 创建链表（初始化）
int dlist_create(NODE**,DATA);
// 向链表插入数据（头插法）
int dlist_addHead(NODE** head,DATA data);
// 向链表插入数据（尾插法）
int dlist_addTail(NODE** head,DATA data);
// 向链表插入数据（中间插法）
int dlist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* dlist_find(const NODE* head,DATA data);
// 链表数据更新
int dlist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void dlist_showAll(const NODE* head);
// 链表数据删除
int dlist_delete(NODE** head,DATA data);
// 链表回收
void dlist_destroy(NODE** head);
#endif
  • dlist.c 
    #include "dlist.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int dlist_create(NODE** head,DATA data)
{
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    pNew -> data = data;
    pNew -> prev = pNew -> next = NULL;
   
    *head = pNew;
    return 0;
}
int dlist_addHead(NODE** head,DATA data)
{
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = *head;
   
    if(*head)
     (*head) -> prev = pNew;
    *head = pNew;
    return 0;
}
int dlist_addTail(NODE** head,DATA data)
{
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = NULL;
   
    NODE* p = *head;
    if(!p)
   {
        *head = pNew;
        return 0;
   }
    while(p -> next)
   {
        p  = p -> next;
   }
    p -> next    = pNew;
    pNew -> prev = p;
    return 0;
}
int dlist_insert(NODE** head,DATA pos,DATA data)
{
    NODE *pNew  = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
      return -1;
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = NULL;
    NODE* p = *head, *q = NULL;
    if(!p)
   {
         *head = pNew;
         return 0;
   }
    if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
   {
         pNew -> next = p;
         p -> prev    = pNew;
         *head        = pNew;
         return 0;
   } 
    while(p)
   {
        if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
       {
            pNew -> next  = p;
            pNew -> prev  = q;
            p    -> prev  = pNew;
            q    -> next  = pNew;
            return 0;
       } 
         q = p;
         p = p -> next;
   }
    q -> next = pNew;
    pNew -> prev = q;
   
    return 0;
}
int dlist_delete(NODE** head,DATA data)
{
    NODE* p = *head;
    if(!p)
      return -1;
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
   {
         if(p -> next == NULL)
         {
              *head = NULL;
              free(p);
              return 0;
         }
         *head        = p -> next;
         p -> next -> prev = NULL;
         free(p);
         return 0;
   }
    
    while(p)
   {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
       {
             p -> prev -> next  =  p -> next;
             if(p -> next == NULL)
                  p -> prev -> next  = NULL;
             else
                  p -> next -> prev  = p -> prev;
             free(p) ;
             return 0;
       }
         p  = p -> next;
   }
    return -1;
}
NODE* dlist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    
    while(p)
   {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
            return (NODE*)p;
        p  = p -> next;
   } 
    return NULL;
}
int dlist_update(const NODE* head,DATA old,DATA newdata)
{
    NODE* pFind = NULL;
    if(pFind = dlist_find(head,old))
   {
        pFind -> data = newdata;
        return 0;
   } 
    return -1;
}
void dlist_destroy(NODE** head)
{
   NODE *p = *head, *q = NULL;
   
   while(p)
   {
        q = p;
        p = p -> next;
        free(q);
   }
   *head = NULL;
}
void dlist_showAll(const NODE* head)
{
    const NODE* p = head;
    while(p)
   {
        printf("%d ",p -> data);
        p = p -> next;
   }
    printf("\n");
}
  • dlist_main.c 
    #include "dlist.h"
#include <stdio.h>
#define OP   2  
int main(void)
{
    NODE*  head = NULL;
    int a[] = {1,3,5,7,9};
    int n = sizeof a / sizeof a[0];
    register int i = 0;
    for(; i < n; i++)
      dlist_addTail(&head,a[i]);
    dlist_showAll(head);
    while(1)
   {
#if (OP == 0)
        DATA   data;
        NODE   *pFind = NULL;
        printf("请输入要查找的数据(-1 退出):");
        scanf("%d",&data);
        if(data == -1)
           break;
        if(!(pFind = dlist_find(head,data)))
       {
            puts("查找的数据不存在,请重试...");
            continue;
       }  
        printf("在内存地址为 %p 的内存空间中找到了 %d\n",&(pFind->data),pFind->data);
#elif (OP == 1)   
        DATA   data;
        NODE   *pFind = NULL;
        printf("请输入要插入位置的数据(-1 退出):");
        scanf("%d",&data);
        if(data == -1)
           break;
        if(dlist_insert(&head,data,407))
       {
            puts("插入失败,请重试...");
            continue;
       }
        dlist_showAll(head);
#else
        DATA   data;
        NODE   *pFind = NULL;
        printf("请输入要删除位置的数据(-1 退出):");
        scanf("%d",&data);
        if(data == -1)
           break;
        if(dlist_delete(&head,data))
       {
            puts("删除失败,请重试...");
            continue;
       }
        dlist_showAll(head);
#endif
   }
     
    dlist_destroy(&head);
    puts("=====回收后====");
    dlist_showAll(head);
    
    return 0;
}

七、循环双向链表【扩展】

1、完整代码（循环没有头插尾插，只有中间插法）

循环双向链表是在双向链表的基础上进行了改动，整体改动不是很大，请看下面代码：

  • dclist.h

    #ifndef __DCLIST_H
#define __DCLIST_H
typedef  int   DATA; 
typedef struct node
{
    DATA          data;
    struct node  *prev;
    struct node  *next;
}NODE;
int  dclist_add(NODE** head,DATA data);
int dclist_delete(NODE** head,DATA data);
NODE* dclist_find(const NODE* head,DATA data);
int dclist_update(const NODE* head,DATA old,DATA newdata);
void dclist_showAll(const NODE* head);
void dclist_destroy(NODE** head);
#endif

  • dclist.c

    #include "dclist.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
static NODE* dclist_create_node(DATA data)
{
    NODE* p  = (NODE*)malloc(sizeof(NODE));
    if(!p)
      return NULL;
    
    p -> data  = data;
    p -> prev  = p;
    p -> next  = p;
    
    return p;
}
/*
@argument: new: 待插入的节点
@argument: prev: 插入后节点的上一个节点
@argument: next: 插入后节点的下一个节点
         
*/
static void  __dclist_add(NODE* new, NODE* prev,NODE* next )
{
    new -> prev = prev;
    new -> next = next;
   
    prev -> next = new;
    next -> prev = new;
}
int  dclist_add(NODE** head,DATA data)
{
    if(*head == NULL)
   {
        *head = dclist_create_node(data);
        int ret = (*head)?0:-1;
        return ret ;
   }
    
    NODE *new = dclist_create_node(data);
    if(!new)
      return -1;
    
    __dclist_add(new,(*head)->prev,*head);
    return 0;
}
static void  __dclist_delete(NODE* del, NODE* prev,NODE* next )
{
    prev -> next = next;
    next -> prev = prev;
    free(del);
}
int  dclist_delete(NODE** head,DATA data)
{
    if(*head == NULL)
        return -1 ;
    NODE *del = dclist_find(*head,data);
    if(!del)
      return -1;
    NODE* p = *head;
    if(del == p)        //删除的是头节点
   {
         if(p -> next == p)   // 唯一的头节点
         {
            *head = NULL;
            free(p);
            return 0;
         }
         p -> prev -> next = p -> next;
         p -> next -> prev = p -> prev;
         *head = p -> next;
         free(p);
         return 0;
   }
    __dclist_delete(del,del->prev,del->next);
    return 0;
}
NODE* dclist_find(const NODE* head,DATA data)
{
    const NODE*  p = head;
    while(p)
   {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
            return (NODE*)p;
        p = p -> next;
        if(p == head)
            break;
   }
    return NULL;
}
int dclist_update(const NODE* head,DATA old,DATA newdata)
{
    NODE* pFind = dclist_find(head,old);
    if(!pFind)
      return -1;
    pFind -> data = newdata;
    return 0;  
}
void dclist_showAll(const NODE* head)
{
    const NODE* p = head;
    while(p)
   {
         printf("%d ",p -> data);
         p  = p -> next;
         if(p == head)
           break;
   }
    printf("\n");
}
void dclist_destroy(NODE** head)
{
    if(*head == NULL)
       return ;
    NODE* p  = *head,*q = NULL;
    p -> prev -> next = NULL;
   
    while(p)
   {
         q  = p ;
         p  = p -> next;
         free(q);
         if(p == *head)
           break;
   }
    *head = NULL;
}

  • dclist_main.c

    #include <stdio.h>
#include "dclist.h"
#define DELETE  
int main(void)
{
    NODE*  head = NULL;
    
    int a[] = {1,3,5,7,9,11,13};
    int n = sizeof a / sizeof a[0];
    register int i = 0;
    for(; i < n ; i++)
       dclist_add(&head,a[i]);
    dclist_showAll(head);
    
    DATA   data ;
    while(1)
   {
  #ifdef DELETE
       printf("请输入要删除的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;       
       if(dclist_delete(&head,data) < 0)
       {
           puts("删除失败,请重试");
           continue;
       }
       dclist_showAll(head);
  #else
       NODE *pFind = NULL;
       printf("请输入要查找的数据:");
       scanf("%d",&data);
       if(data == -1)
          break;
       if(!(pFind = dclist_find(head,data)))
       {
           puts("查找的数据不存在,请重试");
           continue;
       }
       printf("查找数据:%d 内存地址:%p\n",pFind -> data, &(pFind -> data));
  #endif
   }
    dclist_destroy(&head);
    puts("====销毁后====="); 
    dclist_showAll(head);
    return 0;
}

2、使用场合

经过单链表、双链表的学习，可以总结链表的适用场合：

  • 适合用于节点数目不固定，动态变化较大的场合；
  • 适合用于节点需要频繁插入、删除的场合；
  • 适合用于对节点查找效率不十分敏感的场合。

3、内存检测（valgrind）

安装:   sudo apt-get install valgrind
格式:   valgrind [options] prog-and-args
例子： valgrind --tool=memcheck --leak-check=full --log-file=./result.txt ./dlist
注意: 在使用valgrind 工具进行内存监测时，要求可执行程序在编译时，要为gcc 编译器指定 -g 选项；

章节作业

（单向链表）

【1】建立一个包含若干整数的单向链表，比如: 1,2,3,4,51,2,3,4,5

通过某些算法将其中各个节点逆转，比如: 5,4,3,2,15,4,3,2,1

（约瑟夫环、单向循环链表）

解析：主要是分析如何将链表倒转，画图讲解。

参考代码：

// 倒转单向链表
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}node, *list;
void init_list(list *p2head)
{
    *p2head = (list)malloc(sizeof(node));
   (*p2head)->next = NULL;
}
void insert(list head, int num)
{
    list pnew = (list)malloc(sizeof(node));
    assert(pnew);
    pnew->data = num;
    pnew->next = NULL;
    /* find the last node */
    list p = head;
    while(p->next != NULL)
        p = p->next;
    /* add the new node to the tail */
    p->next = pnew;
}
void show(list head)
{
    list p = head->next;
    while(p != NULL){
        printf("%d\t", p->data);
        p = p->next;
   }
    printf("\n");
}
void revert(list head)
{
    list p = head->next, q;
    head->next = NULL;
    while(p){
        q = p;
        p = p->next;
        q->next = head->next;
        head->next = q;
   }
}
int main(void)
{
    list head;
    init_list(&head);
    printf("input some integers('#' to terminate):\n");
    int num;
    while((scanf("%d", &num)) == 1){
        insert(head, num);
   }
    show(head);
    revert(head);
    show(head);
    return 0;
}

【2】罗马人占领乔塔帕特后，犹太人与Josephus及他的朋友躲到一个洞中，族人决定宁愿死也 不要被敌人找到，于是决定了一个自杀方式，所有人排成一个圆圈，由第1个人开始报数，每报 数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

然而Josephus和他的朋友并不想死，Josephus要他的朋友先假装遵从，他将朋友与自己安排在两个特 殊的位置，于是逃过了这场死亡游戏。

现在假设有n个人形成一个单向循环链表，求最后剩余的两个节点。

解析：主要是分析有头结点和没有头结点，对本题的影响。一般情况下链表带头结点是比较方便的，但是对于本题，约瑟夫环问题，带上头结点的链表反而不利于操作，画图讲解。

参考代码：

// 约瑟夫环问题
#include <stdbool.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct node
{
    int data;
    struct node *next;
}listnode, *link;
/*** initialization ***/
void init_list(link *p2head)
{
    *p2head = NULL;
}
/*** insert ***/
void insert(link *p2head, int x)
{
    link pnew = (link)malloc(sizeof(listnode));
    if(*p2head == NULL)
   {
        pnew->data = x;
        pnew->next = pnew;
        *p2head = pnew;
   }
    else
   {
        link p = *p2head;
        /* find the tail of the list */
        while(p->next != *p2head)
            p = p->next;
        pnew->data = x;
        p->next = pnew;
        pnew->next = *p2head;
   }
    return;
}
/*** delete ***/
struct node *delete(struct node *p2delete)
{
    struct node *q = p2delete;
    while(q->next != p2delete)
        q = q->next;
    q->next = p2delete->next;
    free(p2delete);
    return q->next;
}
void show(struct node *head)
{
    struct node *p = head;
    while(p!=NULL && p->next!=head)
   {
        printf("%d\t", p->data);
        p = p->next;
   }
    printf("%d\n", p->data);
}
int main(void)
{
    struct node *head;
    int num, i;
    /********************************
        initialize the list
    ********************************/
    init_list(&head);
    scanf("%d", &num);
    /***************************************
        create a signal-loop list
    ***************************************/
    for(i=0; i<num; i++)
        insert(&head, i+1);
    show(head);
    
    /**********************************************
        kick the 3th node from the list
    **********************************************/
    struct node *present = head->next->next;
    while(present->next != present)
   {
        /********************************************
        delete the node pointed by 'p' from the list
        ********************************************/
        present = delete(present);
        /*********************
        point to the next one
        *********************/
        present = present->next->next;
   }
    printf("answer: \n%d\n", present->data);
    //show(head);
    
        return 0;
}

（单向链表）

【1】建立一个包含若干整数的单向链表，比如: 1,2,3,4,51,2,3,4,5

通过某些算法将其中各个节点逆转，比如: 5,4,3,2,15,4,3,2,1

（约瑟夫环、单向循环链表）

解析

主要是分析如何将链表倒转，画图讲解。

参考代码
// 倒转单向链表
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}node, *list;
void init_list(list *p2head)
{
    *p2head = (list)malloc(sizeof(node));
   (*p2head)->next = NULL;
}
void insert(list head, int num)
{
    list pnew = (list)malloc(sizeof(node));
    assert(pnew);
    pnew->data = num;
    pnew->next = NULL;
    /* find the last node */
    list p = head;
    while(p->next != NULL)
        p = p->next;
    /* add the new node to the tail */
    p->next = pnew;
}
void show(list head)
{
    list p = head->next;
    while(p != NULL){
        printf("%d\t", p->data);
        p = p->next;
   }
    printf("\n");
}
void revert(list head)
{
    list p = head->next, q;
    head->next = NULL;
    while(p){
        q = p;
        p = p->next;
        q->next = head->next;
        head->next = q;
   }
}
int main(void)
{
    list head;
    init_list(&head);
    printf("input some integers('#' to terminate):\n");
    int num;
    while((scanf("%d", &num)) == 1){
        insert(head, num);
   }
    show(head);
    revert(head);
    show(head);
    return 0;
}

【2】罗马人占领乔塔帕特后，犹太人与Josephus及他的朋友躲到一个洞中，族人决定宁愿死也 不要被敌人找到，于是决定了一个自杀方式，所有人排成一个圆圈，由第1个人开始报数，每报 数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

然而Josephus和他的朋友并不想死，Josephus要他的朋友先假装遵从，他将朋友与自己安排在两个特 殊的位置，于是逃过了这场死亡游戏。

现在假设有n个人形成一个单向循环链表，求最后剩余的两个节点。

解析

主要是分析有头结点和没有头结点，对本题的影响。一般情况下链表带头结点是比较方便的，但是对于本题，约瑟夫环问题，带上头结点的链表反而不利于操作，画图讲解。

参考代码
// 约瑟夫环问题
#include <stdbool.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct node
{
    int data;
    struct node *next;
}listnode, *link;
/*** initialization ***/
void init_list(link *p2head)
{
    *p2head = NULL;
}
/*** insert ***/
void insert(link *p2head, int x)
{
    link pnew = (link)malloc(sizeof(listnode));
    if(*p2head == NULL)
   {
        pnew->data = x;
        pnew->next = pnew;
        *p2head = pnew;
   }
    else
   {
        link p = *p2head;
        /* find the tail of the list */
        while(p->next != *p2head)
            p = p->next;
        pnew->data = x;
        p->next = pnew;
        pnew->next = *p2head;
   }
    return;
}
/*** delete ***/
struct node *delete(struct node *p2delete)
{
    struct node *q = p2delete;
    while(q->next != p2delete)
        q = q->next;
    q->next = p2delete->next;
    free(p2delete);
    return q->next;
}
void show(struct node *head)
{
    struct node *p = head;
    while(p!=NULL && p->next!=head)
   {
        printf("%d\t", p->data);
        p = p->next;
   }
    printf("%d\n", p->data);
}
int main(void)
{
    struct node *head;
    int num, i;
    /********************************
        initialize the list
    ********************************/
    init_list(&head);
    scanf("%d", &num);
    /***************************************
        create a signal-loop list
    ***************************************/
    for(i=0; i<num; i++)
        insert(&head, i+1);
    show(head);
    
    /**********************************************
        kick the 3th node from the list
    **********************************************/
    struct node *present = head->next->next;
    while(present->next != present)
   {
        /********************************************
        delete the node pointed by 'p' from the list
        ********************************************/
        present = delete(present);
        /*********************
        point to the next one
        *********************/
        present = present->next->next;
   }
    printf("answer: \n%d\n", present->data);
    //show(head);
    
        return 0;
}

绝望地学习
关注
顺序表和链表【数据结构】【基于C语言实现】【一站式速通】
2301_79241364的博客
01-23 1528
本文详细介绍了单向链表，双向链表的实现，深入分析了各种数据结构的优缺点，剖析了它们的演变过程，通俗易懂，万字总结，小白无痛学习，同时也欢迎大牛的指导~
第1章 顺序表和单链表
m0_74916669的博客
08-26 1275
顺序存储中，由于逻辑关系是用物理位置来表达的，因此从上述示例代码可以很清楚看到，增删数据 都非常困难，需要成片地移动数据。顺序表对数据节点的增删操作是很不友好的。总结其特点如下：优点1. 不需要多余的信息来记录数据间的关系，存储密度高2. 所有数据顺序存储在一片连续的内存中，支持立即访问任意一个随机数据，比如上述顺序表中第 个节点是 s->data[i]缺点1. 插入、删除时需要保持数据的物理位置反映其逻辑关系，一般需要成片移动数据2. 当数据节点数量较多时，需要一整片较大的连续内存空间。
数据结构顺序表（C语言实现）
Sveinn的博客
04-14 411
数据结构顺序表（C语言实现） 头文件和函数申明 #include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef struct Arr //定义了一个数据类型，该数据类型的名字叫做struct Arr,该数据类型含有三个成员PBase,len,cnt { int *pBase;//储存的是数组...
C语言数据结构——链表
wxk2227814847的博客
01-28 2038
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
C语言实现基础数据结构——链表
小何代码咖啡馆
01-29 1332
链表是线性表中的其中一种结构，链表在物理存储结构上是非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。在链表中，每一个存储空间都是独立申请的（需要添加数据时申请），也被称为节点（结点）在双向链表中，存在头结点，即默认有一个节点，但是该节点中不存储有效数据，只存储指向上一个节点和下一个节点的地址。在双向链表中，空链表的含义是除了头结点以外没有其他任何节点（即没有存储有效数据的节点）基于链表实现顺序表学习到的通讯录项目。在双向链表中，头结点是不可以删除的。链表实现时需要熟悉的三个。
c语言数据结构——链表的实现及其基本操作
希望自己从编程小白变成大佬
04-06 4440
顺序表的问题及思考中间/头部的插入删除，时间复杂度为O(N)增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面我们给出了链表的结构，让我们来看看吧。
【数据结构】静态链表、循环单链表、双向链表、双向循环链表
ChenZHIHAO_y的博客
03-27 998
静态链表、循环单链表、双向链表、双向循环链表的概念与基本操作代码实现
『初阶数据结构 • C语言』⑨ - 基于结点的数据结构——链表（单链表&&双向循环链表）附完整源码
花想云的博客
01-15 1495
像数组一样，链表也用来表示一系列的元素。事实上，能用数组来做的事情，一般也可以用链表来做。然而，链表的实现跟数组是不一样的，在不同场景它们会有不同的性能表现。计算机的内存就像一大堆格子，每格都可以用来保存比特形式的数据。当要创建数组时，程序会在内存中找出一组连续的空格子，给它们起个名字，以便你的应用存放数据。我们之前说过，计算机能够直接跳到数组的某一索引上。如果代码要求它读取索引 4的值，那么计算机只需一步就可以完成任务。
数据结构——C语言实现链表
热门推荐
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3215
简述双向链表概念、C语言实现双向链表
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
weixin_45991687的博客
04-01 3632
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 382
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1122
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 529
看到的社区的一个知识总结，这里记录一下。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1253
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表数据结构详解：单链表、双向链表与循环链表
"该资源是一份关于链表数据结构的学习资料，主要涵盖了链表的基本概念、分类以及核心操作，适合大一学生或对数据结构感兴趣的读者。文档详细讲解了链表与数组的区别、链表的三种类型：单链表、双向链表和循环链表，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值