【C语言】深入浅出：C语言链表的全面解析

最新推荐文章于 2024-09-06 08:50:54 发布
最新推荐文章于 2024-09-06 08:50:54 发布
阅读量1.8k 收藏 28
点赞数 81
分类专栏： C语言 文章标签： c语言 链表 c++ 数据结构 双向链表 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EleganceJiaBao/article/details/140833833
版权

LuckiBit

目录

链表是一种常见的数据结构，由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的最大特点是节点在内存中不必连续存储，因而在插入和删除操作时更加高效。下面我们将详细讲解C语言中单链表、双向链表和循环链表的基本概念、实现方法及其相关操作。

以下是本文中提到的重要内容及其简要描述的表格：

内容描述
单链表（Singly Linked List）每个节点包含一个数据域和一个指针域，指向下一个节点。头节点指向链表的第一个节点，尾节点指向 NULL。
双向链表（Doubly Linked List）每个节点包含数据域、前驱指针和后继指针，允许双向遍历。前驱指针指向前一个节点，后继指针指向后一个节点。
循环链表（Circular Linked List）最后一个节点的指针域指向头节点，形成一个环形结构。可以是单向的或双向的。
创建节点动态分配内存，为链表创建新节点。
插入节点将新节点插入到链表中的特定位置或链表末尾。
删除节点从链表中移除特定节点，并释放相应的内存。
动态内存分配链表节点在运行时动态分配和释放内存，不需要在编译时指定大小。
插入和删除效率插入和删除操作效率高，在已知节点位置的情况下时间复杂度为 O(1)。
随机访问效率随机访问效率低，无法通过索引直接访问元素，必须从头开始遍历，时间复杂度为 O(n)。
应用常用于实现队列、栈、图和网络的表示等数据结构，以及内存管理中的空闲块管理。

一、单链表

1. 基本概念

单链表（Singly Linked List）是一种链表结构，其中每个节点包含一个数据域和一个指针域，指针域指向下一个节点。链表的第一个节点称为头节点，最后一个节点的指针域指向NULL，表示链表的结束。

节点结构定义
struct Node {
    int data;          // 数据域
    struct Node* next; // 指针域，指向下一个节点
};

2. 创建链表

示例代码
#include <stdio.h>
#include <stdlib.h>

// 节点结构定义
struct Node {
    int data;
    struct Node* next;
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 添加节点到链表末尾
void append(struct Node** headRef, int data) {
    struct Node* newNode = createNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
    } else {
        struct Node* temp = *headRef;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

// 打印链表
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

int main() {
    struct Node* head = NULL;
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);
    printList(head);
    return 0;
}
输出结果
1 -> 2 -> 3 -> NULL

3. 插入节点

示例代码
// 在特定位置插入新节点
void insertAfter(struct Node* prevNode, int data) {
    if (prevNode == NULL) {
        printf("前置节点不能为空\n");
        return;
    }
    struct Node* newNode = createNode(data);
    newNode->next = prevNode->next;
    prevNode->next = newNode;
}

int main() {
    struct Node* head = NULL;
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);
    insertAfter(head->next, 4); // 在第二个节点后插入4
    printList(head);
    return 0;
}
输出结果
1 -> 2 -> 4 -> 3 -> NULL

4. 删除节点

示例代码
// 删除包含特定数据的节点
void deleteNode(struct Node** headRef, int key) {
    struct Node* temp = *headRef;
    struct Node* prev = NULL;

    if (temp != NULL && temp->data == key) {
        *headRef = temp->next;
        free(temp);
        return;
    }

    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }

    if (temp == NULL) return;

    prev->next = temp->next;
    free(temp);
}

int main() {
    struct Node* head = NULL;
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);
    deleteNode(&head, 2); // 删除包含数据2的节点
    printList(head);
    return 0;
}
输出结果
1 -> 3 -> NULL

二、双向链表

1. 基本概念

双向链表（Doubly Linked List）是一种链表结构，其中每个节点包含三个部分：数据域、前驱指针域和后继指针域。前驱指针指向前一个节点，后继指针指向后一个节点。双向链表允许双向遍历。

节点结构定义
struct DNode {
    int data;
    struct DNode* prev; // 前驱指针
    struct DNode* next; // 后继指针
};

2. 创建双向链表

示例代码
#include <stdio.h>
#include <stdlib.h>

// 双向链表节点结构定义
struct DNode {
    int data;
    struct DNode* prev;
    struct DNode* next;
};

// 创建新节点
struct DNode* createDNode(int data) {
    struct DNode* newNode = (struct DNode*)malloc(sizeof(struct DNode));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 添加节点到链表末尾
void appendD(struct DNode** headRef, int data) {
    struct DNode* newNode = createDNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
    } else {
        struct DNode* temp = *headRef;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->prev = temp;
    }
}

// 打印双向链表
void printDList(struct DNode* head) {
    struct DNode* temp = head;
    while (temp != NULL) {
        printf("%d <-> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

int main() {
    struct DNode* head = NULL;
    appendD(&head, 1);
    appendD(&head, 2);
    appendD(&head, 3);
    printDList(head);
    return 0;
}
输出结果
1 <-> 2 <-> 3 <-> NULL

3. 插入节点

示例代码
// 在特定节点后插入新节点
void insertAfterD(struct DNode* prevNode, int data) {
    if (prevNode == NULL) {
        printf("前置节点不能为空\n");
        return;
    }
    struct DNode* newNode = createDNode(data);
    newNode->next = prevNode->next;
    prevNode->next = newNode;
    newNode->prev = prevNode;
    if (newNode->next != NULL) {
        newNode->next->prev = newNode;
    }
}

int main() {
    struct DNode* head = NULL;
    appendD(&head, 1);
    appendD(&head, 2);
    appendD(&head, 3);
    insertAfterD(head->next, 4); // 在第二个节点后插入4
    printDList(head);
    return 0;
}
输出结果
1 <-> 2 <-> 4 <-> 3 <-> NULL

4. 删除节点

示例代码
// 删除包含特定数据的节点
void deleteDNode(struct DNode** headRef, int key) {
    struct DNode* temp = *headRef;

    while (temp != NULL && temp->data != key) {
        temp = temp->next;
    }

    if (temp == NULL) return;

    if (temp->prev != NULL) {
        temp->prev->next = temp->next;
    } else {
        *headRef = temp->next;
    }

    if (temp->next != NULL) {
        temp->next->prev = temp->prev;
    }

    free(temp);
}

int main() {
    struct DNode* head = NULL;
    appendD(&head, 1);
    appendD(&head, 2);
    appendD(&head, 3);
    deleteDNode(&head, 2); // 删除包含数据2的节点
    printDList(head);
    return 0;
}
输出结果
1 <-> 3 <-> NULL

三、循环链表

1. 基本概念

循环链表（Circular Linked List）是一种链表结构，其中最后一个节点的指针域指向链表的头节点，形成一个环形结构。循环链表可以是单向的或双向的。

节点结构定义
struct CNode {
    int data;
    struct CNode* next;
};

2. 创建循环链表

示例代码
#include <stdio.h>
#include <stdlib.h>

// 循环链表节点结构定义
struct CNode {
    int data;
    struct CNode* next;
};

// 创建新节点
struct CNode* createCNode(int data) {
    struct CNode* newNode = (struct CNode*)malloc(sizeof(struct CNode));
    newNode->data = data;
    newNode->next = newNode; // 初始时，节点的next指向自身
    return newNode;
}

// 添加节点到循环链表末尾
void appendC(struct CNode** headRef, int data) {
    struct CNode* newNode = createCNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
    } else {
        struct CNode* temp = *headRef;
        while (temp->next != *headRef) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->next = *headRef;
    }
}

// 打印循环链表
void printCList(struct CNode* head) {
    if (head == NULL) return;
    struct CNode* temp = head;
    do {
        printf("%d -> ", temp->data);
        temp = temp->next;
    } while (temp != head);
    printf("(back to head)\n");
}

int main() {
    struct CNode* head = NULL;
    appendC(&head, 1);
    appendC(&head, 2);
    appendC(&head, 3);
    printCList(head);
    return 0;
}
输出结果
1 -> 2 -> 3 -> (back to head)

3. 插入节点

在循环链表中插入节点时，需要特别小心处理环的连接，以确保新节点正确地链接到链表中。

示例代码
// 在特定位置后插入新节点
void insertAfterC(struct CNode* prevNode, int data) {
    if (prevNode == NULL) {
        printf("前置节点不能为空\n");
        return;
    }
    struct CNode* newNode = createCNode(data);
    newNode->next = prevNode->next;
    prevNode->next = newNode;
}

int main() {
    struct CNode* head = NULL;
    appendC(&head, 1);
    appendC(&head, 2);
    appendC(&head, 3);
    insertAfterC(head->next, 4); // 在第二个节点后插入4
    printCList(head);
    return 0;
}
输出结果
1 -> 2 -> 4 -> 3 -> (back to head)

4. 删除节点

在循环链表中删除节点时，特别要注意处理头节点的删除和尾节点的循环连接。

示例代码
// 删除包含特定数据的节点
void deleteCNode(struct CNode** headRef, int key) {
    if (*headRef == NULL) return;

    struct CNode *curr = *headRef, *prev = NULL;

    // 处理头节点可能是目标节点的情况
    if (curr->data == key) {
        while (curr->next != *headRef) {
            curr = curr->next;
        }
        if (curr == *headRef) { // 链表只有一个节点
            free(*headRef);
            *headRef = NULL;
        } else { // 链表有多个节点
            curr->next = (*headRef)->next;
            free(*headRef);
            *headRef = curr->next;
        }
        return;
    }

    // 查找目标节点
    do {
        prev = curr;
        curr = curr->next;
    } while (curr != *headRef && curr->data != key);

    // 未找到目标节点
    if (curr == *headRef) return;

    // 解除目标节点
    prev->next = curr->next;
    free(curr);
}

int main() {
    struct CNode* head = NULL;
    appendC(&head, 1);
    appendC(&head, 2);
    appendC(&head, 3);
    deleteCNode(&head, 2); // 删除包含数据2的节点
    printCList(head);
    return 0;
}
输出结果
1 -> 3 -> (back to head)

四、链表的优缺点与应用

1. 优点

  1. 动态内存分配：链表可以在运行时动态分配和释放内存，不需要在编译时指定大小。
  2. 插入和删除效率高：在已知节点位置的情况下，链表的插入和删除操作非常高效，时间复杂度为 O(1)。

2. 缺点

  1. 额外的存储开销：每个节点需要存储指针，增加了内存使用。
  2. 随机访问不便：无法通过索引直接访问元素，必须从头开始遍历，时间复杂度为 O(n)。

3. 常见应用

  1. 实现数据结构：如队列、栈等。
  2. 内存管理：如动态内存分配器的空闲块管理。
  3. 图和网络的表示：如邻接表表示法。

五、总结

链表是一种重要的基础数据结构，适用于频繁的插入和删除操作。通过本篇详细讲解了单链表、双向链表和循环链表的概念和实现，以及各类常用操作的示例代码。掌握链表的使用对于理解更复杂的数据结构和算法具有重要意义。

六、结束语

  1. 本节内容已经全部介绍完毕，希望通过这篇文章，大家对C语言链表有了更深入的理解和认识。
  2. 感谢各位的阅读和支持，如果觉得这篇文章对你有帮助，请不要吝惜你的点赞和评论，这对我们非常重要。再次感谢大家的关注和支持！点我关注❤️

相关文章：

LuckiBit
关注
  • 81
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C语言到C++快速入门
m0_74000825的博客
04-21 909
C语言快速进阶C++ 无废话纯干货
【C语言】深入理解C语言数据类型：从结构体到共用体和枚举的全面解析
m0_75045191的博客
07-17 645
结构体定义由关键字struct和结构体名组成结构体类型结构体变量struct stuint num；//定义结构体stu//定义结构体变量lucy结构体类型结构体变量struct stuint num；}lucy;//定义结构体stu同时定义结构体变量lucy一次性结构体structint num；}lucy;注：结构体变量可以与成员名相同。访问成员方式：lucy.num(继承类型，int型）lucy.name（char型，数组名代表首元素地址）定义。
深入理解C语言中的链表操作
m0_50914476的博客
02-07 297
C语言因其接近硬件的特性和高效性，在系统编程、嵌入式开发等领域仍然占据着不可替代的地位。链表作为一种基础且重要的数据结构，在C语言中的应用非常广泛。通过对比上述三个程序，我们可以深入理解C语言中单链表、双向链表和多种链表操作（如增加、删除、查找、修改等）的实现方法。
C语言链表简单概述
BEYONDmonster的博客
03-17 209
链表：链表是一种常见的重要的数据结构，是动态的进行存储分配的一种结构。 链表的组成： 头指针：存放一个地址，该地址指向第一个元素。 节点：用户需要的实际数据和链接节点的指针。 例如： //定义一个学生结构体，包括学号、成绩以及结构体指针。 struct student{ int num; float score; struct student *next; } void main(){ /...
C语言雅瑟夫问题
07-03
### C语言雅瑟夫问题解析 #### 一、引言 在计算机科学领域，雅瑟夫问题（Josephus Problem）是一种著名的理论问题，通常用来测试编程能力和算法理解能力。本篇将详细介绍一个基于C语言实现的雅瑟夫问题解决方案，...
数据结构与算法分析：C语言描述第二版课后习题答案及代码.zip
06-14
《数据结构与算法分析：C语言描述第二版》是一本深受程序员喜爱的经典教材，它深入浅出地介绍了数据结构和算法的基本概念、设计方法以及分析技巧。这本书的课后习题是检验学习效果和提升技能的重要途径。这个压缩包...
李春葆：数据结构习题与解析（C语言版）
10-06
这本书以其深入浅出的讲解方式和丰富的实例，深受广大计算机科学和技术专业学生的喜爱。在C语言的背景下，它将抽象的数据结构概念与实际编程相结合，帮助读者理解和掌握数据结构的核心原理。 数据结构是计算机科学...
北京邮电大学C语言课件.zip
05-14
北京邮电大学的C语言课件，以其深入浅出的讲解和丰富的实例，为学习者提供了宝贵的参考资料。以下是基于这些课件中的关键知识点的详细解读。 1. **C语言基础**：C语言的基础知识包括数据类型（如int, char, float等...
单片机C语言程序设计实训：100个代码示例解析
[单片机C语言程序设计实训：100个代码示例解析](https://img-blog.csdnimg.cn/d9eafc749401429a9569776e0dbc9e38.png) # 1. 单片机C语言程序设计基础** 单片机C语言是一种专为单片机编程而设计的编程语言，它继承了...
【最新华为OD机试E卷-支持在线评测】分糖果(100分)-多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
09-03 434
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM金牌🏅️团队| 多次AK大厂笔试 ｜ 编程一对一辅导。
TFT液晶面板中应用的高度集成的电源管理芯片（PMIC）-iML1942
nanfeng775a的博客
09-03 805
电源管理芯片 - iML1942是一个高度集成的电源管理IC为TFT液晶面板。它具有完整的I2C接口来编程各种参数。该设备包括一个针对AVDD的电流模式升压调节器，一个针对VBK1的同步升压转换器。
牛牛替换（c语言)
scy2429828663的博客
09-01 851
【代码】牛牛替换（c语言)
C语言-第六章-加餐：其他自定义类型
2303_78095330的博客
09-02 1486
之前我们说过，局部变量的空间在内存的栈区，全局变量的空间在内存的静态区，这个两个区由系统自己回收和管理空间；这是因为它的两个成员只占用了1个字节(可能是2个字节，具体看平台差异)的空间，但是int类型的对齐数是4，所以这个结构体的最大对齐数是4，结构体的大小至少是最大对齐数的整数倍，即4字节。同理，b 只能表示0、1。看上图，我们要得到结构体的地址，就需要得到红线的长度（也就是相对于地址0的差值），我们假设有一个相同类型的结构体变量对齐到地址为0的地方 ，那么黄线长度和红线长度是一样的。
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1344
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 428
Linux 内核编程 /proc 例子代码
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
最新发布
填坑之路
09-06 383
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 310
【C++ Primer Plus习题】9.1
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 254
【代码】C++友类匿名对象，运算符重载。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值