【数据结构】链表

最新推荐文章于 2024-06-16 12:36:18 发布
最新推荐文章于 2024-06-16 12:36:18 发布
阅读量725 收藏
点赞数 2
分类专栏： 数据结构学习 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46006376/article/details/131846489
版权

【数据结构】链表

链表是一种常见的数据结构，用于存储一系列的元素。链表是由一组节点组成，每个节点包含数据和一个指向下一个节点的指针。C语言中，链表可以用结构体和指针来实现。下面分别介绍单链表、循环单链表和双向链表的实现。

1、单链表

单链表是一种最简单的链表，它的每个节点只包含一个指向下一个节点的指针。单链表的最后一个节点指向NULL，表示链表的结尾。单链表只能从头节点开始遍历，无法双向遍历。因此，单链表的插入和删除操作相对简单，但查找操作需要遍历整个链表。

单链表的定义通常使用一个结构体来表示节点：

struct Node {
    int data;
    struct Node *next;
};

其中，data表示节点存储的数据，next是指向下一个节点的指针。

单链表的基本操作包括：创建、遍历、插入、删除和查找。

1.1 创建单链表

创建单链表需要动态分配内存，一个一个地创建节点，并将每个节点连接起来。下面是一个创建单链表的示例代码：

struct Node *createLinkedList(int data[], int n) {
    struct Node *head = NULL, *tail = NULL;
    for (int i = 0; i < n; i++) {
        struct Node *node = (struct Node*)malloc(sizeof(struct Node));
        node->data = data[i];
        node->next = NULL;
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    return head;
}

其中，data是一个整型数组，n表示数组的长度。该函数返回一个指向单链表头节点的指针。

1.2 遍历单链表

遍历单链表就是依次访问链表中的每个节点，并处理节点中的数据。可以使用一个循环来遍历链表，每次将指针移动到下一个节点。遍历单链表的代码如下：

void traverseLinkedList(struct Node *head) {
    struct Node *p = head;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

1.3 插入节点

在链表中插入一个节点通常需要两个步骤：先创建一个新节点，然后将它插入到链表中正确的位置。对于单链表，需要将新节点插入到前一个节点和后一个节点之间，而对于双向链表，还需要更新新节点的前驱指针。下面是在单链表中插入节点的代码：

void insertNode(struct Node *head, int index, int data) {
    struct Node *p = head;
    for (int i = 0; i < index - 1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("Error: Invalid index\n");
        return;
    }
    struct Node *node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->next = p->next;
    p->next = node;
}

其中，head是链表的头节点，index表示要插入的位置（从1开始），data表示要插入的数据。该函数会在链表的第index个节点之前插入一个新节点。

1.4 删除节点

删除链表中的一个节点通常也需要两个步骤：先找到要删除的节点，然后将它从链表中移除。对于单链表，需要将前一个节点的next指针指向后一个节点，而对于双向链表，还需要更新后一个节点的前驱指针。下面是在单链表中删除节点的代码：

void deleteNode(struct Node *head, int index) {
    struct Node *p = head;
    for (int i = 0; i < index - 1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL || p->next == NULL) {
        printf("Error: Invalid index\n");
        return;
   }
    struct Node *node = p->next;
    p->next = node->next;
    free(node);
}

其中，head是链表的头节点，index表示要删除的节点位置（从1开始）。该函数会删除链表的第index个节点。

1.5 查找节点

查找链表中的一个节点需要从头节点开始遍历链表，比较每个节点的数据，直到找到目标节点或遍历完整个链表。下面是在单链表中查找节点的代码：

int searchNode(struct Node *head, int data) {
    struct Node *p = head;
    int index = 1;
    while (p != NULL && p->data != data) {
        p = p->next;
        index++;
    }
    if (p == NULL) {
        return -1;
    } else {
        return index;
    }
}

其中，head是链表的头节点，data是要查找的数据。该函数会返回目标节点在链表中的位置（从1开始），如果未找到则返回-1。

2、循环单链表

循环单链表是一种特殊的单链表，它的最后一个节点指向头节点，形成一个循环。循环单链表可以用于模拟环形队列等场景。循环单链表的定义和单链表类似，只需要将最后一个节点的next指针指向头节点即可。

循环单链表的操作和单链表大致相同，只需要在遍历链表时判断是否到达了头节点即可。下面是创建循环单链表的代码：

struct Node *createCircularLinkedList(int data[], int n) {
    struct Node *head = NULL, *tail = NULL;
    for (int i = 0; i < n; i++) {
        struct Node *node = (struct Node*)malloc(sizeof(struct Node));
        node->data = data[i];
        node->next = NULL;
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    tail->next = head; // 将最后一个节点指向头节点
    return head;
}

3、双向链表

双向链表是一种比单链表更复杂的链表，它每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。双向链表可以实现更多的功能，例如双向遍历和删除指定元素等。双向链表的定义通常使用一个结构体来表示节点：

struct Node {
    int data;
    struct Node *prev;
    struct Node *next;
};

其中，data表示节点存储的数据，prev是指向前一个节点的指针，next是指向后一个节点的指针。

双向链表相比单链表，插入和删除操作相对复杂，但查找操作可以双向遍历，效率更高。

3.1 创建双向链表

创建双向链表需要动态分配内存，一个一个地创建节点，并将每个节点连接起来。下面是一个创建双向链表的示例代码：

struct Node *createDoublyLinkedList(int data[], int n) {
    struct Node *head = NULL, *tail = NULL;
    for (int i = 0; i < n; i++) {
        struct Node *node = (struct Node*)malloc(sizeof(struct Node));
        node->data = data[i];
        node->prev = NULL;
        node->next = NULL;
        if (head == NULL) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            node->prev = tail;
            tail = node;
        }
    }
    return head;
}

3.2 遍历双向链表

遍历双向链表可以从头节点或尾节点开始遍历，可以使用两个指针分别指向头节点和尾节点，依次访问每个节点，并处理节点中的数据。遍历双向链表的代码如下：

3.2 遍历双向链表

遍历双向链表可以从头节点或尾节点开始遍历，可以使用两个指针分别指向头节点和尾节点，依次访问每个节点，并处理节点中的数据。遍历双向链表的代码如下：

void traverseDoublyLinkedList(struct Node *head) {
    struct Node *p = head;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void traverseDoublyLinkedListReverse(struct Node *tail) {
    struct Node *p = tail;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->prev;
    }
    printf("\n");
}

其中，traverseDoublyLinkedList函数从头节点开始遍历链表，traverseDoublyLinkedListReverse函数从尾节点开始遍历链表。

3.3 插入节点

在双向链表中插入一个节点需要三个步骤：先创建一个新节点，然后将它插入到链表中正确的位置，最后更新相邻节点的指针。下面是在双向链表中插入节点的代码：

void insertNode(struct Node *head, int index, int data) {
    struct Node *p = head;
    for (int i = 0; i < index - 1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("Error: Invalid index\n");
        return;
    }
    struct Node *node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->prev = p;
    node->next = p->next;
    if (p->next != NULL) {
        p->next->prev = node;
    }
    p->next = node;
}

其中，head是链表的头节点，index表示要插入的位置（从1开始），data表示要插入的数据。该函数会在链表的第index个节点之前插入一个新节点。

3.4 删除节点

删除链表中的一个节点需要三个步骤：先找到要删除的节点，然后将它从链表中移除，最后更新相邻节点的指针。下面是在双向链表中删除节点的代码：

void deleteNode(struct Node *head, int index) {
    struct Node *p = head;
    for (int i = 0; i < index - 1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("Error: Invalid index\n");
        return;
    }
    if (p->prev != NULL) {
        p->prev->next = p->next;
    }
    if (p->next != NULL) {
        p->next->prev = p->prev;
    }
    free(p);
}

其中，head是链表的头节点，index表示要删除的节点位置（从1开始）。该函数会删除链表的第index个节点。

3.5 查找节点

查找链表中的一个节点可以双向遍历链表，比较每个节点的数据，直到找到目标节点或遍历完整个链表。下面是在双向链表中查找节点的代码：

int searchNode(struct Node *head, int data) {
    struct Node *p = head;
    int index = 1;
    while (p != NULL && p->data != data) {
        p = p->next;
        index++;
    }
    if (p == NULL) {
        return -1;
    } else {
        return index;
    }
}

int searchNodeReverse(struct Node *tail, int data) {
    struct Node *p = tail;
    int index = 1;
    while (p != NULL && p->data != data) {
        p = p->prev;
        index++;
    }
    if (p == NULL) {
        return -1;
    } else {
        return index;
    }
}

其中，searchNode函数从头节点开始遍历链表，searchNodeReverse函数从尾节点开始遍历链表。这两个函数都会返回目标节点在链表中的位置（从1开始），如果未找到则返回-1。

总结

在C语言中，单链表、循环单链表和双向链表都是常用的数据结构，它们各有优缺点，适用于不同的场景。在实现链表时，需要注意节点的定义、头节点和尾节点的处理、遍历、插入、删除和查找等操作。

对于单链表，节点定义为包含数据和指向下一个节点的指针的结构体。头节点是指向第一个节点的指针，尾节点为空指针。在插入和删除节点时，需要注意处理头节点和尾节点的变化。

对于循环单链表，节点定义和单链表相同，但尾节点指向第一个节点。在插入和删除节点时，需要注意尾节点的变化。

对于双向链表，节点定义为包含数据和指向前一个节点和后一个节点的指针的结构体。头节点和尾节点分别是第一个节点和最后一个节点。在插入和删除节点时，需要更新相邻节点的前驱和后继指针。

在实现链表时，需要注意内存管理，避免内存泄漏和悬挂指针等问题。同时，要注意边界条件的处理，避免越界访问或非法操作。

最后，链表是一种动态数据结构，能够高效地实现插入、删除和查找等操作。但是，链表的缺点是不支持随机访问，访问任意位置的时间复杂度是O(n)，而且需要额外的空间存储指针。因此，在不同的场景下，需要根据实际需求选择合适的数据结构。

淡看宝贝
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5097
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
数据结构之链表详解
m0_56440500的博客
08-20 3879
链表是一种常见的数据结构，它可以用来存储一组数据，并支持快速的插入和删除操作。相比于数组，链表的大小可以动态地增加或减小，因此在某些场景下更加灵活和高效。本文将详细介绍链表的定义、基本操作和应用场景，希望能够帮助读者深入理解链表的原理和实现。链表是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在内存中任意位置，因此它们不必按照顺序连续存储。链表的头节点是第一个节点，尾节点是最后一个节点，它们分别由指向第一个节点和最后一个节点的指针来表示。
C/C++丨结构(struct) and 链表(linked list)
最新发布
qq_35766450的博客
06-16 754
《C语言程序设计》第七章结构和链表学习笔记
数据结构之——链表
xqx_999的博客
10-06 4231
链表的介绍，单链表和双向链表的接口实现。
数据结构笔记链表篇
猫狗鼠鱼的储物间
10-28 198
否则，遍历链表，找到待删除节点的前驱节点，然后将前驱节点的指针指向待删除节点的后继节点即可。这里用的是尾插法，创建一个临时指针temp1,然后让temp1指向A，而A此时其实就是第一个节点，看它的next指向的是不是NULL，由上面的图我们知道，由于A的next指向的是NULL，所以直接退出循环，让链表的最后一个节点指向新节点。最后咱们进行操作，让要插入的节点的next指针指向插入位置的前一个节点的next指针指向的节点，最后把插入位置的前一个节点的next指针指向插入的节点，实现新节点的任意位置的插入。
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
数据结构 链表
04-08
数据结构 简单的链表结构 》》》》》》》》》》》
数据结构链表测试
05-02
在本项目“数据结构链表测试”中，我们专注于链表的一种特殊形式：单链表。 单链表是一种线性数据结构，每个节点包含两部分：数据域和指针域。数据域存储实际的数据，而指针域存储指向下一个节点的引用。单链表的...
数据类型struct Node与Node的使用问题
千的博客
03-13 7318
C语言和C++中结构体定义与使用的区别问题网站给出的List结构定义原代码功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 问题 在PAT网站做题目“02-线性结构1 两个有序链表序列的合并 (15 分)”时，遇到了代码编译错误的问
[最全]2023年CSP-J组初赛真题及答案
m0_52563006的博客
09-17 1055
[最全]2023年CSP-J组初赛真题及答案
【c语言】链表（适合初学者）
weixin_74337975的博客
04-07 2300
C语言中的链表是一种常见的数据结构，它由一系列的节点（node）组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表可以用来表示各种数据结构，例如队列、堆栈、树等。在C语言中，链表的节点通常是通过结构体来定义的。int data;在这个结构体中，data是节点存储的数据元素，next是指向下一个节点的指针。因为next指向的是另一个Node类型的结构体，所以需要使用类型来定义。链表的头指针是指向第一个节点的指针，通常称为head。对于一个空链表，头指针为NULL。链表的尾节点的next。
数据结构之链表（练习）
Black_vv的博客
07-18 406
C语言链表练习
C语言实现链表（链式存储结构）
BeiXi's Blog
01-14 4027
链表（链式存储结构）及创建 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 例如，使用链表存储 {1,2,3}，数据的物理存储状态如下图所示： 我们看到，上图 根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的...
链表-基础算法题
CenShell
12-27 610
0.基本概念 单链表结点的结构 struct ListNode { int data; struct ListNode* next; ListNode() {} ListNode(int data, ListNode* next = NULL) : data(data), next(next) {} }; 有无头结点只对尾插法的操作有影响，对头插法没有影响 ⚠️尾插法一定要提供尾指针 1.添加/删除链表节点 添加值为 x 的结点 带头结点的递增有序的单链表 L 添加一个值为 x 的结
数据结构链表操作大全，面向对象封装
数据结构链表操作大全是一种在面向对象编程中对链表进行操作的封装方法。链表是一种重要的数据结构，它可以动态地存储和处理数据。本文将介绍链表的创建、插入、删除、查找等操作，并在面向对象的方法上进行封装。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值