C语言-双向链表的详解和实现

最新推荐文章于 2024-08-07 17:33:57 发布
最新推荐文章于 2024-08-07 17:33:57 发布
阅读量286 收藏 7
点赞数 4
分类专栏： C语言 文章标签： c语言 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42037383/article/details/139972291
版权

实现带头结点的双向链表需要考虑节点的结构和各种操作的实现。双向链表的每个节点除了包含数据和指向下一个节点的指针外，还需要一个指向前一个节点的指针。这使得在双向链表中，可以从任意节点直接访问其前驱和后继节点，提高了某些操作的效率。

双向链表结构定义和操作

结构定义

双向链表的节点结构定义如下：

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

// 双向链表节点结构
typedef struct Node {
    int data;           // 节点数据域
    struct Node* prev;  // 指向前一个节点的指针
    struct Node* next;  // 指向后一个节点的指针
} Node;

// 双向链表结构体定义
typedef struct {
    Node* head; // 头结点指针，指向链表的头部
    int size;   // 链表中节点的数量
} DoublyLinkedList;
常用操作及时间复杂度分析
  1. 创建双向链表 (createDoublyLinkedList)
// 创建空的双向链表
DoublyLinkedList* createDoublyLinkedList() {
    DoublyLinkedList* list = malloc(sizeof(DoublyLinkedList));
    if (list == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return NULL;
    }
    
    // 创建头结点
    list->head = malloc(sizeof(Node));
    if (list->head == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        free(list);
        return NULL;
    }
    list->head->prev = NULL;
    list->head->next = NULL;
    list->size = 0;
    
    return list;
}
  • 时间复杂度： O(1)
  • 创建双向链表只涉及分配内存和初始化头结点，操作时间为常数。
  • 2销毁双向链表 (destroyDoublyLinkedList)
// 销毁双向链表
void destroyDoublyLinkedList(DoublyLinkedList* list) {
    if (list == NULL) return;
    
    Node* curr = list->head;
    while (curr != NULL) {
        Node* next = curr->next;
        free(curr);
        curr = next;
    }
    
    free(list);
}
  • 时间复杂度： O(n)
  • 销毁双向链表需要遍历链表的所有节点，并释放每个节点的内存。
  • 3头部插入 (insertAtHead)
// 头部插入节点
void insertAtHead(DoublyLinkedList* list, int data) {
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    
    // 将新节点插入到头结点之后
    newNode->prev = list->head;
    newNode->next = list->head->next;
    if (list->head->next != NULL) {
        list->head->next->prev = newNode;
    }
    list->head->next = newNode;
    
    list->size++; // 链表大小加1
}
  • 时间复杂度： O(1)
  • 在双向链表的头部插入节点只需要修改几个指针的指向，操作时间为常数。
  • 4尾部插入 (insertAtTail)
// 尾部插入节点
void insertAtTail(DoublyLinkedList* list, int data) {
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    newNode->next = NULL;
    
    // 找到尾节点
    Node* tail = list->head;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    
    // 将新节点插入到尾节点之后
    newNode->prev = tail;
    tail->next = newNode;
    
    list->size++; // 链表大小加1
}
  • 时间复杂度： O(n)
  • 在双向链表的尾部插入节点需要遍历整个链表找到尾节点，因此操作时间为线性。
  • 5指定位置插入 (insertAtIndex)
// 指定位置插入节点
void insertAtIndex(DoublyLinkedList* list, int index, int data) {
    if (index < 0 || index > list->size) {
        fprintf(stderr, "Invalid index\n");
        return;
    }
    
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    
    // 找到要插入位置的前一个节点
    Node* curr = list->head;
    for (int i = 0; i < index; i++) {
        curr = curr->next;
    }
    
    // 插入新节点
    newNode->prev = curr;
    newNode->next = curr->next;
    if (curr->next != NULL) {
        curr->next->prev = newNode;
    }
    curr->next = newNode;
    
    list->size++; // 链表大小加1
}
  • 时间复杂度： O(n)
  • 在双向链表的指定位置插入节点需要先遍历找到指定位置的前一个节点，因此操作时间为线性。
  • 6头部删除 (deleteAtHead)
// 头部删除节点
void deleteAtHead(DoublyLinkedList* list) {
    if (list->head->next == NULL) {
        fprintf(stderr, "List is empty\n");
        return;
    }
    
    // 删除头节点后的第一个节点
    Node* firstNode = list->head->next;
    list->head->next = firstNode->next;
    if (firstNode->next != NULL) {
        firstNode->next->prev = list->head;
    }
    
    free(firstNode);
    list->size--; // 链表大小减1
}
  • 时间复杂度： O(1)
  • 删除双向链表的头节点只需要修改几个指针的指向，并释放原头节点的内存，操作时间为常数。
  • 7尾部删除 (deleteAtTail)
// 尾部删除节点
void deleteAtTail(DoublyLinkedList* list) {
    if (list->head->next == NULL) {
        fprintf(stderr, "List is empty\n");
        return;
    }
    
    // 找到尾节点的前一个节点
    Node* prev = list->head;
    while (prev->next->next != NULL) {
        prev = prev->next;
    }
    
    // 删除尾节点
    Node* tail = prev->next;
    prev->next = NULL;
    
    free(tail);
    list->size--; // 链表大小减1
}
  • 时间复杂度： O(n)
  • 删除双向链表的尾节点需要先遍历找到尾节点的前一个节点，然后修改指针，释放尾节点的内存，因此操作时间为线性。
  • 8指定位置删除 (deleteAtIndex)
// 指定位置删除节点
void deleteAtIndex(DoublyLinkedList* list, int index) {
    if (index < 0 || index >= list->size) {
        fprintf(stderr, "Invalid index\n");
        return;
    }
    
    // 找到要删除的节点
    Node* curr = list->head;
    for (int i = 0; i <= index; i++) {
        curr = curr->next;
    }
    
    // 删除节点
    curr->prev->next = curr->next;
    if (curr->next != NULL) {
        curr->next->prev = curr->prev;
    }
    
    free(curr);
    list->size--; // 链表大小减1
}
  • 时间复杂度： O(n)
  • 删除双向链表的指定位置节点需要先遍历找到指定位置的节点，然后修改指针，释放节点的内存，因此操作时间为线性。
  • 9按值查找 (findByValue)
// 按值查找节点
Node* findByValue(DoublyLinkedList* list, int data) {
    Node* curr = list->head->next;
    while (curr != NULL && curr->data != data) {
        curr = curr->next;
    }
    return curr;
}
  • 时间复杂度： O(n)
  • 按值查找双向链表中的节点需要遍历整个链表，直到找到目标节点或者到达链表末尾，因此操作时间为线性。
  • 10按索引查找 (findByIndex)
// 按索引查找节点
Node* findByIndex(DoublyLinkedList* list, int index) {
    if (index < 0 || index >= list->size) {
        fprintf(stderr, "Invalid index\n");
        return NULL;
    }
    
    Node* curr = list->head->next;
    for (int i = 0; i < index; i++) {
        curr = curr->next;
    }
    
    return curr;
}
  • 时间复杂度： O(n)
  • 按索引查找双向链表中的节点需要遍历链表，直到找到指定索引位置的节点，因此操作时间为线性。
  • 11修改节点数据 (updateNode)
// 修改节点数据
void updateNode(Node* node, int newData) {
    if (node != NULL) {
        node->data = newData;
    }
}
  • 时间复杂度： O(1)
  • 直接修改节点的数据域，操作时间与链表长度无关，因此是常数时间复杂度。

总结

双向链表通过每个节点存储前驱和后继节点的指针，支持从任意位置直接访问前后节点，使得插入、删除等操作在某些场景下比单链表更加高效。然而，由于需要额外的指针空间和更复杂的指针操作，双向链表的空间复杂度较高，并且在插入、删除操作涉及到节点查找时，时间复杂度与链表长度成正比。

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

// 双向链表节点结构
typedef struct Node {
    int data;           // 节点数据域
    struct Node* prev;  // 指向前一个节点的指针
    struct Node* next;  // 指向后一个节点的指针
} Node;

// 双向链表结构体定义
typedef struct {
    Node* head; // 头结点指针，指向链表的头部
    int size;   // 链表中节点的数量
} DoublyLinkedList;

// 创建空的双向链表
DoublyLinkedList* createDoublyLinkedList() {
    DoublyLinkedList* list = malloc(sizeof(DoublyLinkedList));
    if (list == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return NULL;
    }
    
    // 创建头结点
    list->head = malloc(sizeof(Node));
    if (list->head == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        free(list);
        return NULL;
    }
    list->head->prev = NULL;
    list->head->next = NULL;
    list->size = 0;
    
    return list;
}

// 销毁双向链表
void destroyDoublyLinkedList(DoublyLinkedList* list) {
    if (list == NULL) return;
    
    Node* curr = list->head;
    while (curr != NULL) {
        Node* next = curr->next;
        free(curr);
        curr = next;
    }
    
    free(list);
}

// 头部插入节点
void insertAtHead(DoublyLinkedList* list, int data) {
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    
    // 将新节点插入到头结点之后
    newNode->prev = list->head;
    newNode->next = list->head->next;
    if (list->head->next != NULL) {
        list->head->next->prev = newNode;
    }
    list->head->next = newNode;
    
    list->size++; // 链表大小加1
}

// 尾部插入节点
void insertAtTail(DoublyLinkedList* list, int data) {
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    newNode->next = NULL;
    
    // 找到尾节点
    Node* tail = list->head;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    
    // 将新节点插入到尾节点之后
    newNode->prev = tail;
    tail->next = newNode;
    
    list->size++; // 链表大小加1
}

// 指定位置插入节点
void insertAtIndex(DoublyLinkedList* list, int index, int data) {
    if (index < 0 || index > list->size) {
        fprintf(stderr, "Invalid index\n");
        return;
    }
    
    Node* newNode = malloc(sizeof(Node));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return;
    }
    newNode->data = data;
    
    // 找到要插入位置的前一个节点
    Node* curr = list->head;
    for (int i = 0; i < index; i++) {
        curr = curr->next;
    }
    
    // 插入新节点
    newNode->prev = curr;
    newNode->next = curr->next;
    if (curr->next != NULL) {
        curr->next->prev = newNode;
    }
    curr->next = newNode;
    
    list->size++; // 链表大小加1
}

// 头部删除节点
void deleteAtHead(DoublyLinkedList* list) {
    if (list->head->next == NULL) {
        fprintf(stderr, "List is empty\n");
        return;
    }
    
    // 删除头节点后的第一个节点
    Node* firstNode = list->head->next;
    list->head->next = firstNode->next;
    if (firstNode->next != NULL) {
        firstNode->next->prev = list->head;
    }
    
    free(firstNode);
    list->size--; // 链表大小减1
}

// 尾部删除节点
void deleteAtTail(DoublyLinkedList* list) {
    if (list->head->next == NULL) {
        fprintf(stderr, "List is empty\n");
        return;
    }
    
    // 找到尾节点的前一个节点
    Node* prev = list->head;
    while (prev->next->next != NULL) {
        prev = prev->next;
    }
    
    // 删除尾节点
    Node* tail = prev->next;
    prev->next = NULL;
    
    free(tail);
    list->size--; // 链表大小减1
}

// 指定位置删除节点
void deleteAtIndex(DoublyLinkedList* list, int index) {
    if (index < 0 || index >= list->size) {
        fprintf(stderr, "Invalid index\n");
        return;
    }
    
    // 找到要删除的节点
    Node* curr = list->head;
    for (int i = 0; i <= index; i++) {
        curr = curr->next;
    }
    
    // 删除节点
    curr->prev->next = curr->next;
    if (curr->next != NULL) {
        curr->next->prev = curr->prev;
    }
    
    free(curr);
    list->size--; // 链表大小减1
}

// 按值查找节点
Node* findByValue(DoublyLinkedList* list, int data) {
    Node* curr = list->head->next;
    while (curr != NULL && curr->data != data) {
        curr = curr->next;
    }
    return curr;
}

// 按索引查找节点
Node* findByIndex(DoublyLinkedList* list, int index) {
    if (index < 0 || index >= list->size) {
        fprintf(stderr, "Invalid index\n");
        return NULL;
    }
    
    Node* curr = list->head->next;
    for (int i = 0; i < index; i++) {
        curr = curr->next;
    }
    
    return curr;
}

// 修改节点数据
void updateNode(Node* node, int newData) {
    if (node != NULL) {
        node->data = newData;
    }
}

// 打印双向链表
void printDoublyLinkedList(DoublyLinkedList* list) {
    Node* curr = list->head->next;
    printf("Doubly Linked List: ");
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("NULL\n");
}

int main() {
    DoublyLinkedList* list = createDoublyLinkedList();
    
    // 插入节点示例
    insertAtHead(list, 1);
    insertAtTail(list, 2);
    insertAtIndex(list, 1, 3);
    
    // 打印链表
    printDoublyLinkedList(list);
    
    // 删除节点示例
    deleteAtHead(list);
    deleteAtIndex(list, 1);
    
    // 打印链表
    printDoublyLinkedList(list);
    
    // 按值查找节点示例
    insertAtHead(list, 4);
    Node* node = findByValue(list, 3);
    if (node != NULL) {
        printf("Node found with value 3\n");
    } else {
        printf("Node with value 3 not found\n");
    }
    
    // 修改节点数据示例
    node = findByValue(list, 4);
    if (node != NULL) {
        updateNode(node, 5);
        printf("Node value updated to 5\n");
    }
    
    // 打印链表
    printDoublyLinkedList(list);
    
    // 销毁链表
    destroyDoublyLinkedList(list);
    
    return 0;
}

菜林子
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3259
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
【C 数据结构】双向链表
普罗米修斯的博客
04-11 726
双链表删除结点时，只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可。每个节点存在前后两个指针，分别指向前驱节点和后继节点。
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 7425
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表------双向链表详解
weixin_51134816的博客
05-05 1773
双链表在增删改查方面比单链表方便很多，但在存储空间方面，单链表是比双链表更优的，根据场景不同，两种链表都能发挥出其优点。在学习链表方面，还是要注意区分头指针和头结点！不懂就查，不懂就问，不会就多练！
C语言数据结构-----链表类型详解及链表练习题
qq_57425280的博客
11-11 563
之前我讲解了循序表以及单链表，接下来我会在介绍几个不同的链表，并举例相关习题使大家能够更加深入的理解。前期内容如下：链接:链接:链接: [双向链表增删查改的代码实现] 紧张制作中。
c语言双向链表的作用,C语言之双向链表详解及实例代码
weixin_42377538的博客
05-17 219
1，双向链表简介。双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。2，例子要求：完成双向链表的插入、删除以及查找，将学生管理系统使用的数组，以双向链表的方式实现，能够支持无限制的学生人数的增删改查以及保存。3，代码实现。#include #inc...
C语言链表详解（通俗易懂）
weixin_61661271的博客
06-05 5万+
线性表是实际中广泛应用的重要数据结构，本文用通俗易懂的方法讲解它。
c语言双向链表的作用,C语言双向链表的表示与实现实例详解
weixin_29195217的博客
05-17 498
1.概述：C语言中一种更复杂的链表是“双向链表”或“双面链表”。其表中的每个节点有两个连接：一个指向前一个节点，(当这个“连接”为第一个“连接”时，指向空值或者空列表)；而另一个指向下一个节点，(当这个“连接”为最后一个“连接”时，指向空值或者空列表)一个双向链表有三个整数值: 数值, 向后的节点链接, 向前的节点链接在一些低级语言中, XOR-linking 提供一种在双向链表中通过用一个词来表...
C语言之双向链表详解及实例代码
12-31
完成双向链表的插入、删除以及查找，将学生管理系统使用的数组，以双向链表的方式实现，能够支持无限制的学生人数的增删改查以及保存。 3，代码实现。 #include #include #include #include typedef struct ...
C语言实例-双向链表增删改查
09-11
【双向链表详解】 双向链表（Doubly Linked List）是计算机科学中的一种基本数据结构，它在单链表的基础上扩展了数据节点的指针结构。与单链表仅包含一个指向下一个节点的指针不同，双向链表的每个节点包含两个指针...
深入理解计算机系统 CSAPP lab：bomb
apple_50569014的博客
08-07 130
【代码】深入理解计算机系统 CSAPP lab：bomb。
Flink开发语言使用Java还是Scala合适？
AI逍遥子
08-05 424
Apache Flink是一个用于大规模数据流处理和事件驱动应用的开源框架，它支持多种编程语言，其中Java和Scala是最常用的两种。总的来说，Java和Scala都可以用于Flink开发，并没有绝对的“更好”，选择哪一种取决于您的具体需求和偏好。
Flink 开发语言选择 —— Java vs Scala
qq_42072014的博客
08-03 1338
Flink 支持多种编程语言，包括 Java 和 Scala。这两种语言都有其独特的特性和优势，因此，在选择开发语言时需要考虑多个方面，如性能、社区支持、开发效率等。
胖东来企业文化指导手册.pptx
最新发布
08-07
胖东来企业文化指导手册.pptx
[毕业设计]基于PHP与MySQL的学生成绩查看系统.zip
08-07
[毕业设计]基于PHP与MySQL的学生成绩查看系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值