双向链表（c语言）

最新推荐文章于 2024-07-03 20:18:23 发布
最新推荐文章于 2024-07-03 20:18:23 发布
阅读量201 收藏 1
点赞数
分类专栏： 代码 文章标签： c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aeneag/article/details/120765201
版权

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

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

链表应该在学习数据结构中最简单的一种了吧，其实在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;
}

小结

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

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

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

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

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

灵魂碰撞

艾恩凝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
双向链表(C语言)
weixin_43405004的博客
10-17 238
双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点（前驱），另一个指针用指向下一个节点（后继）。 本文主要是对双向链表的基本操作，主要包括双向链表的创建，插入节点，删除节点，还有输出节点的数据等。 结点的构造 typedef struct node { ​ int data; ​ struct node *prev; ​ struct node *next; }Node，*pNode; 基本操作 双向链表的创建 双向链表的创建同样像单链表一样
双向链表（C语言）
17的博客
10-07 808
双向链表
掌握链表：C语言中的链表详解与实践应用
最新发布
2302_79999839的博客
07-03 1062
C语言，数据结构，链表，编程学习，实际应用
双向链表(数据结构)(C语言)
outdated_socks的博客
05-08 4299
双向链表的结构体定义、双向链表的初始化、关于无头单向非循环链表无需初始化函数，顺序表、带头双向循环链表需要的思考、双向链表在pos位置之前插入x、双向链表的打印 双链表删除pos位置的结点、双向链表的尾插、关于单链表的尾插需要用到二级指针，双向链表不需要用到二级指针的思考、双向链表的判空、双向链表的尾删、双向链表的头插、双向链表的头删、双向链表查找值为x的结点、双向链表的销毁、双向链表的修改、双向链表删除值为x的结点、双向链表计算结点总数(不计phead)、双向链表获取第
C语言数据结构之双向链表
Qurry的博客
09-21 1307
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
C语言双向链表
anyi365416的专栏
01-17 86
　　今天写了点双向链表的各种操作，写插入的时候费了点时间，不过，现在看来还是值得耗费那点时间去写的，这种小东西应该能信手拈来才行啊。 1 /*双向链表*/ 2 #include <stdio.h> 3 #include <string.h> /*strcmp(const char *,const char *) return 0 is ...
双向链表C语言实现
12-13
本文将详细讲解如何使用C语言来实现一个双向链表，并涵盖按照ID序列插入、删除、更新和修改等操作。 双向链表与单链表不同，它在每个节点中不仅存储数据，还包括指向前后节点的指针。这种特性使得双向链表可以在...
C语言实现双向链表
09-03
在C语言中，双向链表是一种非常重要的数据结构，它具有前向和后向两个指针，可以方便地进行节点的插入、删除和查找等操作。以下是对标题和描述中涉及的知识点的详细说明： 首先，我们需要定义一个双向链表的节点...
DOUBLE_LINK.rar_DOUBLE_LINK_doublelink_双向链表_双向链表C语言_链表 实现
09-24
**双向链表详解** 双向链表（Double-Linked List）是一种数据结构，它与单向链表相似，但每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这种设计使得在链表中的前进和后退操作同样高效，...
循环双向链表（C语言）
09-17
循环双向链表，实现了插入、查找特定的节点、删除等功能，是自己花了半天的时间写完的。
C语言-双向链表
qq_64831425的博客
02-25 894
C语言-双链表
c语言的双向链表
如山石的系统虚拟化之路
04-20 401
双向链表，是平常编程用的最多的一个数据结构。 上面实现最关键的就是： 1、抽象出前驱结点与后驱结点的两个概念 2、这两个节点,旧的后驱结点变成前驱结点，新的后驱结点通过malloc进行生成，从而实现链表的结点的增加。 下面是具体实例，测试通过： #include <stdio.h> 2 #include <stdlib.h> 3 4 //定义...
双向链表C语言
毛豆的专栏
12-21 4594
链表结构定义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 126
为了得到一个简洁的C语言实现的双向链表，本篇参照数据结构书籍对双向链表的做了一些修改，内容有： 　　1.合并分离的头文件和实现文件，认识更为直观； 　　2.修改函数名和变量名，更贴近自身的理解； 　　3.删除了返回首节点、尾节点等功能更为单一的函数，留下其主干。 实现思路： 　　1.定义一个双向链表 　　2.进行初始化工作：调用initList()，构造一个空的双向链表 　 　　3...
双向链表-C语言版
Small_White
11-13 1247
不是自己亲自完成代码，你永远都想不到要注意的细节在哪里！！！
C 双向链表
weixin_33748818的博客
09-13 142
单链表的结点都只有一个指向下一个结点的指针 单链表的数据元素无法直接访问其前驱元素 逆序访问单链表中的元素是极其耗时的操作！ len = LinkList_Length(list); for (i=len-1; len&gt;=0; i++) //O(n) { LinkListNode *p = LinkList_Get(list, i); //O(n)...
双向链表c语言倒序打印
05-07
以下是C语言中双向链表倒序打印的示例代码： ```c #include #include // 双向链表节点结构体 typedef struct Node { int data; struct Node* prev; struct Node* next; } Node; // 在链表末尾插入节点 void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

艾恩凝

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

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

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

打赏作者

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

抵扣说明：

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

余额充值