双向链表（c语言）

最新推荐文章于 2025-11-04 14:07:39 发布
原创 最新推荐文章于 2025-11-04 14:07:39 发布 · 283 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #链表

什么是链表？链表的分类？

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表应该在学习数据结构中最简单的一种了吧，其实在linux内核中链表也随处可见，今天就来重新温习一下链表，该文以双向链表结构讲解。

链表分类

其实链表有好多种，对于初学者来说，被搞的乱七八糟。下面以图解的方式呈现给大家：

​ 

 

看上面的图 2 × 2 × 2 可以得到8种链表，比如非循环带头单向链表就是最简单的，也是学数据结构最开始学习的链表结构。

双向链表

那么双向带头链表，其实对于单链表来说，最大的区别就是在当前链表某个节点，不仅仅知道下一个节点，也知道它的上一个节点

结构

 

typedef struct Node{
    struct Node *prev;
    int elements;
    struct Node *next;
}T_Node,*P_Node;

上面定义了该链表的结构体

创建头结点

首先创建双向链表的头结点

P_Node Create_Head(void)
{
    P_Node head = NULL;
    head = malloc(sizeof(struct Node));
    head->next = NULL;
    head->prev = NULL;
    return head;
}

插入节点元素

插入节点有好多种方式，可以在头部插入，也可以在尾部，同时也可以在尾部插入，在此仅进行尾部插入。

下图是在中间插入元素节点图像：

 

/*
 * 在尾部节点插入新元素，也可以改为头部节点，或者某个位置插入，在此仅仅实现尾部插入新元素
 */
int Insert_Element(P_Node head,int element)
{
    if(!head)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head;
    while(pTemp->next)
        pTemp = pTemp->next;
    P_Node pElement = malloc(sizeof(struct Node));
    pElement->elements = element;
    pTemp->next = pElement;
    pElement->prev = pTemp;
    printf("Insert_Element success : %d\n",element);
    return (0);
}

删除链表节点

写了两个函数一个是删除链表所有节点，包括头结点，另一个是找到某个节点元素，删除这个元素。

/*
 * 删除全部节点
 */
int Delete_List(P_Node head)
{
    if(!head)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head;
    while(pTemp->next)
    {
        pTemp = pTemp->next;
    }

    while(pTemp != NULL)
    {
        free(pTemp);
        pTemp = pTemp->prev;
    }
    return (0);
}
/*
 * 删除某个节点
 */
int Delete_element(P_Node head,int element){
    P_Node pTmp = head->next;
    while(pTmp){
        if(pTmp->elements == element){
            if(!pTmp->prev){//如果是第一个元素
                head->next = pTmp->next;
                pTmp->next = NULL;
                free(pTmp);
                return (0);
            } else if(!pTmp->next){//如果是最后一个元素
                pTmp->prev->next = NULL;
                free(pTmp);
                return (0);
            }else{
                pTmp->prev->next = pTmp->next;
                pTmp->next->prev = pTmp->prev;
                free(pTmp);
                return (0);
            }
        }
        pTmp = pTmp->next;
    }
    printf("Not Found ！\n");
    return (-1);
}

遍历链表元素

遍历链表有好多种方法，在此进提供从头遍历代码参考，遍历链表，其实应该是很简单的操作，一个while循环就可以解决。

int Print_List(P_Node head)
{
    if(!head->next)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head->next;
    printf("list:  ");
    while(pTemp)
    {
        if(!pTemp->next){
            printf("%d\n",pTemp->elements);
        }else{
            printf("%d->",pTemp->elements);
        }
        pTemp = pTemp->next;
    }

    return (0);
}

查找链表元素

查找与遍历类似，只不过在遍历的基础上查找元素是否匹配。

int Find_List(P_Node head,int element)
{
    P_Node pTmp = head->next;
    int i=1;
    while (pTmp)
    {
        if (pTmp->elements == element)
        {
            printf("find %d in %d \n",element,i);
            return i;
        }
        i++;
        pTmp=pTmp->next;
    }
    printf("Not Found ！\n");
    return (-1);
}

完整代码

#include "stdio.h"
#include "stdlib.h"

typedef struct Node{
    struct Node *prev;
    int elements;
    struct Node *next;
}T_Node,*P_Node;

P_Node Create_Head(void)
{
    P_Node head = NULL;
    head = malloc(sizeof(struct Node));
    head->next = NULL;
    head->prev = NULL;
    return head;
}
/*
 * 在尾部节点插入新元素，也可以改为头部节点，或者某个位置插入，在此仅仅实现尾部插入新元素
 */
int Insert_Element(P_Node head,int element)
{
    if(!head)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head;
    while(pTemp->next)
        pTemp = pTemp->next;
    P_Node pElement = malloc(sizeof(struct Node));
    pElement->elements = element;
    pTemp->next = pElement;
    pElement->prev = pTemp;
    printf("Insert_Element success : %d\n",element);
    return (0);
}
/*
 * 遍历链表
 */
int Print_List(P_Node head)
{
    if(!head->next)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head->next;
    printf("list:  ");
    while(pTemp)
    {
        if(!pTemp->next){
            printf("%d\n",pTemp->elements);
        }else{
            printf("%d->",pTemp->elements);
        }
        pTemp = pTemp->next;
    }

    return (0);
}
/*
 * 删除全部节点
 */
int Delete_List(P_Node head)
{
    if(!head)
    {
        printf("Head NULL\n");
        return (-1);
    }
    P_Node pTemp = head;
    while(pTemp->next)
    {
        pTemp = pTemp->next;
    }

    while(pTemp != NULL)
    {
        free(pTemp);
        pTemp = pTemp->prev;
    }
    return (0);
}
/*
 * 删除某个节点
 */
int Delete_element(P_Node head,int element){
    P_Node pTmp = head->next;
    while(pTmp){
        if(pTmp->elements == element){
            if(!pTmp->prev){//如果是第一个元素
                head->next = pTmp->next;
                pTmp->next = NULL;
                free(pTmp);
                return (0);
            } else if(!pTmp->next){//如果是最后一个元素
                pTmp->prev->next = NULL;
                free(pTmp);
                return (0);
            }else{
                pTmp->prev->next = pTmp->next;
                pTmp->next->prev = pTmp->prev;
                free(pTmp);
                return (0);
            }
        }
        pTmp = pTmp->next;
    }
    printf("Not Found ！\n");
    return (-1);
}
/*
 * 查找
 */
int Find_List(P_Node head,int element)
{
    P_Node pTmp = head->next;
    int i=1;
    while (pTmp)
    {
        if (pTmp->elements == element)
        {
            printf("find %d in %d \n",element,i);
            return i;
        }
        i++;
        pTmp=pTmp->next;
    }
    printf("Not Found ！\n");
    return (-1);
}

int main(int argc,char* argv[]){
    P_Node p_head = Create_Head();
    Insert_Element(p_head,1);
    Insert_Element(p_head,2);
    Insert_Element(p_head,3);
    Insert_Element(p_head,4);
    Insert_Element(p_head,5);
    Insert_Element(p_head,6);
    Print_List(p_head);
    Delete_element(p_head,4);
    Print_List(p_head);
    Find_List(p_head,5);
    Delete_List(p_head);
    return 0;
}

小结

代码很简单，手撸双向链表，链表的知识应该是数据结构中最基础的，学习内核知识，链表也是绕不开的弯，如果从事嵌入式行业，这更是基础，会一直与指针打交道，下次有时间手撸一个栈，今天的内容就分享到这了。

以上代码已测试，如有错误欢迎指正。

大家的点赞在看就是我继续创作的动力，如果觉得写的不错，欢迎关注，点赞，收藏，转发，感谢老铁！

该文章首先发布于下面公众号

欢迎关注 #公众号：技术乱舞 一起交流

灵魂碰撞

双向链表(C语言)
weixin_43405004的博客
10-17 365
双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点（前驱），另一个指针用指向下一个节点（后继）。 本文主要是对双向链表的基本操作，主要包括双向链表的创建，插入节点，删除节点，还有输出节点的数据等。 结点的构造 typedef struct node { ​ int data; ​ struct node *prev; ​ struct node *next; }Node，*pNode; 基本操作 双向链表的创建 双向链表的创建同样像单链表一样
C语言-双向链表的详解和实现
qq_42037383的博客
06-25 618
/ 双向链表节点结构int data;// 节点数据域// 指向前一个节点的指针// 指向后一个节点的指针} Node;// 双向链表结构体定义Node* head;// 头结点指针，指向链表的头部int size;// 链表中节点的数量双向链表通过每个节点存储前驱和后继节点的指针，支持从任意位置直接访问前后节点，使得插入、删除等操作在某些场景下比单链表更加高效。
双向链表（C语言）
17的博客
10-07 1003
双向链表
C语言链表详解
最新发布
2502_93500315的博客
11-04 1086
C语言链表详解摘要：链表是一种动态数据结构，由节点(Node)组成，每个节点包含数据域和指针域。相比数组，链表内存分配灵活，插入/删除效率高，但随机访问较慢。常见链表类型包括单链表、双链表和循环链表。文章详细讲解了节点的结构定义、内存分配、连接方式及基本操作，并比较了链表与数组的特性差异。此外，还介绍了链表节点的生命周期管理和常见操作误区，为深入理解链表提供了全面基础。
C语言数据结构之双向链表
Qurry的博客
09-21 1654
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
C语言双向链表
anyi365416的专栏
01-17 153
　　今天写了点双向链表的各种操作，写插入的时候费了点时间，不过，现在看来还是值得耗费那点时间去写的，这种小东西应该能信手拈来才行啊。 1 /*双向链表*/ 2 #include <stdio.h> 3 #include <string.h> /*strcmp(const char *,const char *) return 0 is ...
C语言-双向链表
qq_64831425的博客
02-25 1289
C语言-双链表
DOUBLE_LINK.rar_DOUBLE_LINK_doublelink_双向链表_双向链表C语言_链表 实现
09-24
**双向链表详解** 双向链表（Double-Linked List）是一种数据结构，它与单向链表相似，但每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这种设计使得在链表中的前进和后退操作同样高效，...
双向链表C语言实现
12-13
本文将详细讲解如何使用C语言来实现一个双向链表，并涵盖按照ID序列插入、删除、更新和修改等操作。 双向链表与单链表不同，它在每个节点中不仅存储数据，还包括指向前后节点的指针。这种特性使得双向链表可以在...
C语言实现双向链表
09-03
在C语言中，双向链表是一种非常重要的数据结构，它具有前向和后向两个指针，可以方便地进行节点的插入、删除和查找等操作。以下是对标题和描述中涉及的知识点的详细说明： 首先，我们需要定义一个双向链表的节点...
数据结构之双向链表C语言版
Cukor丘克的博客
10-06 558
数据结构之双向链表C语言版 文章目录数据结构之双向链表C语言版双向链表长什么样？双向链表的节点的结构体双向链表的链表再封装包含的头文件各个子函数的实现创建节点创建链表表头法插入数据表尾法插入数据指定位置插入数据顺序打印链表数据逆序打印链表数据表头法删除数据表尾法删除数据指定位置删除数据主函数测试 数据结构就是用来存放数据的，有很多种数据结构，这篇文章写的是双向链表，用C语言实现。学习数据结构的时候直接复制粘贴源代码是没什么用的。不知道数据结构内部的实现，等于没学。 双向链表长什么样？ 在了解一个数据结构之前
c语言的双向链表
如山石的系统虚拟化之路
04-20 561
双向链表，是平常编程用的最多的一个数据结构。 上面实现最关键的就是： 1、抽象出前驱结点与后驱结点的两个概念 2、这两个节点,旧的后驱结点变成前驱结点，新的后驱结点通过malloc进行生成，从而实现链表的结点的增加。 下面是具体实例，测试通过： #include <stdio.h> 2 #include <stdlib.h> 3 4 //定义...
双向链表(数据结构)(C语言)
outdated_socks的博客
05-08 5295
双向链表的结构体定义、双向链表的初始化、关于无头单向非循环链表无需初始化函数，顺序表、带头双向循环链表需要的思考、双向链表在pos位置之前插入x、双向链表的打印 双链表删除pos位置的结点、双向链表的尾插、关于单链表的尾插需要用到二级指针，双向链表不需要用到二级指针的思考、双向链表的判空、双向链表的尾删、双向链表的头插、双向链表的头删、双向链表查找值为x的结点、双向链表的销毁、双向链表的修改、双向链表删除值为x的结点、双向链表计算结点总数(不计phead)、双向链表获取第
双向链表C语言
毛豆的专栏
12-21 4677
链表结构定义typedef struct node{  char  data[19+1];  struct node *llink;  struct node *rlink;/*上一个，下一个*/};/*创建链表*/int creat_list(struct node *h){   /*  if((h=(struct node *)malloc(sizeof(struct node))
双向链表（c语言版）
weixin_30502965的博客
06-07 186
为了得到一个简洁的C语言实现的双向链表，本篇参照数据结构书籍对双向链表的做了一些修改，内容有： 　　1.合并分离的头文件和实现文件，认识更为直观； 　　2.修改函数名和变量名，更贴近自身的理解； 　　3.删除了返回首节点、尾节点等功能更为单一的函数，留下其主干。 实现思路： 　　1.定义一个双向链表 　　2.进行初始化工作：调用initList()，构造一个空的双向链表 　 　　3...
双向链表-C语言版
Small_White
11-13 1348
不是自己亲自完成代码，你永远都想不到要注意的细节在哪里！！！
双向链表c语言
08-01
### 双向链表的 C 语言实现示例 双向链表是一种链式数据结构，其中每个节点包含数据、指向下一个节点的指针和指向前一个节点的指针。这使得双向链表在插入和删除操作时更加灵活。 #### 数据结构定义 双向链表的节点通常定义如下： ```c typedef struct _Node { int data; // 节点数据 struct _Node* next; // 指向下一个节点 struct _Node* prev; // 指向前一个节点 } Node; typedef Node* Link; ``` #### 初始化双向链表 创建一个空的双向链表通常包括创建一个头节点，该节点不存储实际数据，仅用于标识链表的起始位置： ```c Node* InitList() { Node* head = (Node*)malloc(sizeof(Node)); if (head == NULL) { printf("内存分配失败\n"); exit(1); } head->next = NULL; head->prev = NULL; return head; } ``` #### 插入节点 插入节点到双向链表中需要处理前后指针的关系。例如，在链表的第一个位置插入节点： ```c Node* MakeNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode == NULL) { printf("内存分配失败\n"); exit(1); } newNode->data = data; newNode->next = NULL; newNode->prev = NULL; return newNode; } Node* InsFirst(Node* head, Node* newNode) { if (head == NULL || newNode == NULL) { return NULL; } newNode->next = head->next; if (head->next != NULL) { head->next->prev = newNode; } head->next = newNode; newNode->prev = head; return newNode; } ``` #### 遍历链表 遍历链表可以通过一个函数实现，该函数接受链表头节点和一个打印函数作为参数： ```c void ListTraverse(Node* head, void (*print)(int)) { Node* current = head->next; while (current != NULL) { print(current->data); current = current->next; } } ``` #### 删除节点 删除链表的第一个节点需要更新头节点和下一个节点的指针： ```c void FreeNode(Node* node) { if (node != NULL) { free(node); } } Node* DelFirst(Node* head) { if (head == NULL || head->next == NULL) { return NULL; } Node* firstNode = head->next; head->next = firstNode->next; if (firstNode->next != NULL) { firstNode->next->prev = head; } return firstNode; } ``` #### 销毁链表 销毁整个链表可以释放所有节点占用的内存： ```c void DestroyList(Node* head) { Node* current = head; while (current != NULL) { Node* nextNode = current->next; free(current); current = nextNode; } } ``` #### 完整示例 以下是一个完整的双向链表示例： ```c #include <stdio.h> #include <stdlib.h> typedef struct _Node { int data; struct _Node* next; struct _Node* prev; } Node; Node* InitList() { Node* head = (Node*)malloc(sizeof(Node)); if (head == NULL) { printf("内存分配失败\n"); exit(1); } head->next = NULL; head->prev = NULL; return head; } Node* MakeNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode == NULL) { printf("内存分配失败\n"); exit(1); } newNode->data = data; newNode->next = NULL; newNode->prev = NULL; return newNode; } Node* InsFirst(Node* head, Node* newNode) { if (head == NULL || newNode == NULL) { return NULL; } newNode->next = head->next; if (head->next != NULL) { head->next->prev = newNode; } head->next = newNode; newNode->prev = head; return newNode; } void ListTraverse(Node* head, void (*print)(int)) { Node* current = head->next; while (current != NULL) { print(current->data); current = current->next; } } void FreeNode(Node* node) { if (node != NULL) { free(node); } } Node* DelFirst(Node* head) { if (head == NULL || head->next == NULL) { return NULL; } Node* firstNode = head->next; head->next = firstNode->next; if (firstNode->next != NULL) { firstNode->next->prev = head; } return firstNode; } void DestroyList(Node* head) { Node* current = head; while (current != NULL) { Node* nextNode = current->next; free(current); current = nextNode; } } void print(int data) { printf("数据项为%d\n", data); } int main() { Node* plist = InitList(); Node* p = InsFirst(plist, MakeNode(1)); InsFirst(plist, MakeNode(2)); InsFirst(plist, MakeNode(3)); printf("遍历输出各节点数据项:\n"); ListTraverse(plist, print); printf("除了头节点该链表共有%d个节点\n", 2); // 假设链表中有两个节点 FreeNode(DelFirst(plist)); printf("删除第一个节点后重新遍历输出为:\n"); ListTraverse(plist, print); printf("除了头节点该链表共有%d个节点\n", 1); // 假设链表中有一个节点 DestroyList(plist); printf("链表已被销毁\n"); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

艾恩凝

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

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

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

打赏作者

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

抵扣说明：

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

余额充值