第二章-双链表

已于 2024-01-01 16:35:01 修改
阅读量836 收藏 12
点赞数 23
分类专栏： 考研数据结构 文章标签： c语言 算法 数据结构
于 2023-12-31 22:48:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58464499/article/details/135320462
版权

双链表（Double Linked List）是一种常见的线性数据结构，它在单链表的基础上，为每个节点增加了一个指向前一个节点的指针。因此，双链表中的每个节点都有两个指针：一个指向前一个节点，另一个指向下一个节点。

双链表的优点：

1. 支持双向访问：由于双链表中的节点具有前驱和后继指针，因此我们可以从头节点开始，沿着链表访问到尾节点，也可以从尾节点开始，沿着链表访问到头节点。这一点在需要双向访问场景中具有优势。

2. 更容易实现插入和删除操作：在双链表中，插入和删除一个节点只需要改变相邻节点之间的指针指向关系。相比单链表，双链表在插入和删除操作时更加灵活和高效。

3. 更适合实现一些高级数据结构：例如循环链表、双向循环链表等。

双链表的缺点：

1. 占用更多内存：由于每个节点都需要存储前驱和后继指针，因此双链表比单链表占用更多的内存空间。

2. 复杂程度稍高：由于双链表有多个指针，因此实现相对复杂，需要对边界条件进行更多考虑。

双链表的应用：

1. 缓存替换算法：双链表可以用于实现LRU（最近最少使用）等缓存替换算法。

2. 解决约瑟夫问题：双链表可以用来解决著名的约瑟夫问题（Josephus problem）。

3. 实现数据结构：双链表还可以用于实现其他数据结构，如循环链表、双向循环链表等。

下面是双链表（Doubly Linked List）的各个基本操作的代码实现：

```c
#include <stdio.h>
#include <stdlib.h>

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

// 初始化双链表
void initList(Node** head) {
    *head = NULL;
}

// 判断双链表是否为空
int isEmpty(Node* head) {
    return head == NULL;
}

// 在链表头部插入元素
void insertAtHead(Node** head, int element) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = element;
    newNode->prev = NULL;
    newNode->next = *head;
    
    if (*head != NULL) {
        (*head)->prev = newNode;
    }
    
    *head = newNode;
}

// 在链表尾部插入元素
void insertAtTail(Node** head, int element) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = element;
    newNode->next = NULL;
    
    if (*head == NULL) {
        newNode->prev = NULL;
        *head = newNode;
    } else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        
        current->next = newNode;
        newNode->prev = current;
    }
}

// 在指定位置插入元素
void insertAtPosition(Node** head, int position, int element) {
    if (position <= 0) {
        printf("Error: Invalid position\n");
        return;
    }
    
    if (position == 1) {
        insertAtHead(head, element);
    } else {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = element;
        
        Node* current = *head;
        int count = 1;
        while (current != NULL && count < position - 1) {
            current = current->next;
            count++;
        }
        
        if (current == NULL) {
            printf("Error: Invalid position\n");
            return;
        }
        
        newNode->prev = current;
        newNode->next = current->next;
        
        if (current->next != NULL) {
            current->next->prev = newNode;
        }
        
        current->next = newNode;
    }
}

// 删除链表中第一个出现的指定元素
void deleteElement(Node** head, int element) {
    Node* current = *head;
    
    while (current != NULL && current->data != element) {
        current = current->next;
    }
    
    if (current == NULL) {
        printf("Error: Element not found\n");
        return;
    }
    
    if (current->prev != NULL) {
        current->prev->next = current->next;
    } else {
        *head = current->next;
    }
    
    if (current->next != NULL) {
        current->next->prev = current->prev;
    }
    
    free(current);
}

// 获取链表长度
int getLength(Node* head) {
    int length = 0;
    Node* current = head;
    
    while (current != NULL) {
        length++;
        current = current->next;
    }
    
    return length;
}

// 打印链表中的元素
void printList(Node* head) {
    printf("Linked List: ");
    Node* current = head;
    
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    
    printf("\n");
}

// 销毁链表，释放内存
void destroyList(Node** head) {
    Node* current = *head;
    
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    
    *head = NULL;
}

int main() {
    Node* head;
    initList(&head);
    
    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtTail(&head, 30);
    insertAtPosition(&head, 2, 40);
    
    printList(head);
    
    deleteElement(&head, 20);
    
    printList(head);
    
    int length = getLength(head);
    printf("Length of the linked list: %d\n", length);
    
    destroyList(&head);
    
    return 0;
}
```

这段代码实现了双链表的基本操作，包括初始化双链表 `initList`，判断双链表是否为空 `isEmpty`，在链表头部插入元素 `insertAtHead`，在链表尾部插入元素 `insertAtTail`，在指定位置插入元素 `insertAtPosition`，删除链表中第一个出现的指定元素 `deleteElement`，获取链表长度 `getLength`，打印链表中的元素 `printList`，以及销毁链表，释放内存 `destroyList`。

在 `main` 函数中，我们演示了如何使用这些基本操作来创建链表、插入元素、删除元素、获取链表长度，并打印链表的内容。

需要注意的是，双链表相比单链表多了一个指向前一个节点的指针 `prev`，在插入和删除操作中需要同时更新前一个节点的 `next` 指针，以保持链表的完整性。此外，这只是一个简单的示例，实际应用中可能需要根据具体需求进行修改和扩展。

#include <stdio.h>
#include <stdlib.h>

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

// 初始化双链表
void initList(Node** head) {
    *head = NULL;
}

// 判断双链表是否为空
int isEmpty(Node* head) {
    return head == NULL;
}

// 在链表头部插入元素
void insertAtHead(Node** head, int element) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = element;
    newNode->prev = NULL;
    newNode->next = *head;
    
    if (*head != NULL) {
        (*head)->prev = newNode;
    }
    
    *head = newNode;
}

// 在链表尾部插入元素
void insertAtTail(Node** head, int element) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = element;
    newNode->next = NULL;
    
    if (*head == NULL) {
        newNode->prev = NULL;
        *head = newNode;
    } else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        
        current->next = newNode;
        newNode->prev = current;
    }
}

// 在指定位置插入元素
void insertAtPosition(Node** head, int position, int element) {
    if (position <= 0) {
        printf("Error: Invalid position\n");
        return;
    }
    
    if (position == 1) {
        insertAtHead(head, element);
    } else {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = element;
        
        Node* current = *head;
        int count = 1;
        while (current != NULL && count < position - 1) {
            current = current->next;
            count++;
        }
        
        if (current == NULL) {
            printf("Error: Invalid position\n");
            return;
        }
        
        newNode->prev = current;
        newNode->next = current->next;
        
        if (current->next != NULL) {
            current->next->prev = newNode;
        }
        
        current->next = newNode;
    }
}

// 删除链表中第一个出现的指定元素
void deleteElement(Node** head, int element) {
    Node* current = *head;
    
    while (current != NULL && current->data != element) {
        current = current->next;
    }
    
    if (current == NULL) {
        printf("Error: Element not found\n");
        return;
    }
    
    if (current->prev != NULL) {
        current->prev->next = current->next;
    } else {
        *head = current->next;
    }
    
    if (current->next != NULL) {
        current->next->prev = current->prev;
    }
    
    free(current);
}

// 获取链表长度
int getLength(Node* head) {
    int length = 0;
    Node* current = head;
    
    while (current != NULL) {
        length++;
        current = current->next;
    }
    
    return length;
}

// 打印链表中的元素
void printList(Node* head) {
    printf("Linked List: ");
    Node* current = head;
    
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    
    printf("\n");
}

// 销毁链表，释放内存
void destroyList(Node** head) {
    Node* current = *head;
    
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    
    *head = NULL;
}

int main() {
    Node* head;
    initList(&head);
    
    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtTail(&head, 30);
    insertAtPosition(&head, 2, 40);
    
    printList(head);
    
    deleteElement(&head, 20);
    
    printList(head);
    
    int length = getLength(head);
    printf("Length of the linked list: %d\n", length);
    
    destroyList(&head);
    
    return 0;
}

需要什么私信我
关注
专栏目录
数据结构第二章-2.3
11-23
本章节“数据结构第二章-2.3”主要聚焦于链式数据结构，包括静态链表、顺序表与链表的比较、单链表的建立、循环链表以及双链表。 首先，我们来看静态链表。静态链表是一种在内存中预先分配好连续空间的数据结构，与...
第二章：线性表-31
08-03
此外，环形链表和双向环形链表是线性链表的变体，它们的最后一个节点指向第一个节点，形成一个循环结构，这样的设计在处理循环数据时特别有用。 栈是一种特殊的数据结构，遵循“后进先出”（LIFO）原则。栈主要有两...
数据结构第二章参考答案.doc
12-17
数据结构是计算机科学中最重要的基础知识之一，本章参考答案涵盖了数据结构第二章的主要知识点，包括单链表、顺序表、链表、静态链表、双链表、循环链表、顺序存储结构、链式存储结构、动态内存管理、STL 中的容器等...
Acwing-基础算法-第二章-数据结构
03-24
以下是对标题“Acwing-基础算法-第二章-数据结构”和描述中涉及的知识点的详细说明： 1. **链表**： - 单链表：由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在单链表中，插入和删除操作相对简单，...
第二章：线性表-21
08-03
4. 环形链表：环形链表与普通链表的区别在于最后一个结点的指针不为null，而是指向链表的第一个结点，形成一个循环。这使得遍历链表可以持续进行，而无需检查是否到达链表末尾。 在实际应用中，这些线性表的实现...
C语言中的栈帧
m0_59091453的博客
09-28 622
每当一个函数被调用时，就会在调用栈上创建一个新的栈帧（Stack Frame）。这个栈帧用于存储该函数执行期间所需的所有信息。
Pikachu-Cross-Site Scripting-DOM型xss
guanrongl的专栏
10-02 475
是一个与平台、编程语言无关的接口，它允许程序或脚本动态地访问和更新文档内容、结构和样式，处理后的结果能够成为显示页面的一部分。dom就是一个树状的模型，你可以编写Javascript代码根据dom一层一层的节点，去遍历/获取/修改对应的节点,对象,值。当点击try it ，调用 没有Function方法， 获得 id为demo的元素，然后修改 它的内容，让他为alert弹窗。这样就可以构造一个完整的闭合， what 前面的 '> 可以不用管，当作时文本的一部分；所以，关键是对这段代码构造闭合；
合并两个有序数组（c语言）
scy2429828663的博客
10-01 637
/方法二：elseend2--;int n = 0;printf("请输入m,n的值\n");i < m;i++)i < n;i++)
Pikachu-Cross-Site Scripting-DOM型xss_x
guanrongl的专栏
10-02 225
获取text内容，赋值给xss 然后拼接到 dom 里；查看代码，输入的内容，通过get请求方式，用text 参数带过去；所以str 为 #' onclick="alert(11)">输入，得到xss 结果。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 787
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1208
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
数据结构（链表的操作算法）
m0_61903191的博客
09-30 547
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 777
排序是将多个数据，依指定的顺序进行排列的过程。
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1138
归并排序 in Java
C - Separated Lunch
m0_74304371的博客
10-05 276
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
代码随想录算法训练营day50
最新发布
qq_56445436的博客
10-07 70
【代码】代码随想录算法训练营day50。
代码随想录 101. 孤岛的总面积
qq_53524614的博客
10-05 243
dfs版本，在之前求总面积的基础上增加了判断是否有有边缘位置元素的部分，所以增加了一个notEdge变量，在遇到边缘元素时标记为0，以使所有输出均变为0，此外需要注意，即使遇到了边缘元素也需要先将所有陆地遍历并在visit上标记。毕竟做人需要有始有终）bfs的版本，bfs不需要做递归回溯，所以函数的变量还是不变，只需要在内部增加一个标记是否有边缘元素的变量即可。
16.最接近的三数之和
weixin_61695887的博客
10-04 281
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
代码随想录算法训练营day46
qq_56445436的博客
10-01 272
【代码】代码随想录算法训练营day46。
广工数据结构第二章+双向链表
10-20
广工数据结构第二章主要介绍了线性表的顺序存储和链式存储两种方式，以及它们的实现和应用。其中，链式存储包括单向链表、双向链表和循环链表三种形式。 双向链表是一种常见的链式存储结构，它与单向链表相比，每个节点除了指向后继节点的指针外，还有指向前驱节点的指针。这样可以方便地实现双向遍历和在任意位置插入或删除节点等操作。 在双向链表中，每个节点包含三个部分：数据域、指向前驱节点的指针和指向后继节点的指针。头节点不存储数据，只是为了方便操作而存在。双向链表的插入和删除操作需要修改前驱节点和后继节点的指针，因此需要注意指针的顺序和细节。 双向链表的优点是可以方便地实现双向遍历和在任意位置插入或删除节点等操作，缺点是需要额外的空间存储前驱节点的指针，同时插入和删除操作需要修改两个指针，比较繁琐。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

需要什么私信我

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值