双向单链表的实现

最新推荐文章于 2022-08-03 00:06:34 发布
最新推荐文章于 2022-08-03 00:06:34 发布
阅读量236 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34967445/article/details/72121591
版权 
#include"twowaylinklist.h"  

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
typedef int ElemType;  
typedef struct DulNode  
{  
    struct DulNode *prior;  
    ElemType data;  
    struct DulNode *next;  
}DulNode;  

void judgement_NULL(DulNode *point);                //判断动态内存是否开辟成功  
DulNode * creat();  

void insert(DulNode *head, ElemType x, int i);       //在第i个位置上插入一个值为x的结点  

void delete_element(DulNode *head, ElemType x);       //删除链表中所有的值为x的结点  
void delete_place(DulNode *head, int i);               //删除第i个结点  

void find_element(DulNode *head, int i);                  //寻找第i个结点上的元素  
void find_place(DulNode *head, ElemType x);               //寻找所有值为x的结点  

void length(DulNode *head);  

void output_order(DulNode *head);                       //正向打印链表  
void output_back(DulNode *head);                       //逆序打印链表  

void initslinklist(DulNode *head);                     //释放整个链表  

void sortrank(DulNode *head);                          //对链表进行排序  

int means();                                     //选择以那种方式进行  
[cpp] view plain copy
#include"twowaylinklist.h"  

void judgement_NULL(DulNode *point)              //判断开辟动态内存是否成功  
{  
    if (point == NULL)  
    {  
        perror("out of memory\n");  
        exit(EXIT_FAILURE);  
    }  
}  

DulNode * creat()                        //建立链表，以0作为结束标志  
{  
    printf("开始创建：");  
    ElemType x;  
    DulNode *head, *r, *p;  
    head = (DulNode *)malloc(sizeof(DulNode));                 //开辟一个头结点  
    judgement_NULL(head);  
    head->prior = NULL;  
    r = head;  
    while (1)  
    {  
        scanf("%d", &x);  
        if (x != 0)  
        {  
            p = (DulNode *)malloc(sizeof(DulNode));  
            p->data = x;  
            r->next = p;  
            p->prior = r;  
            r = p;  
        }  
        else  
            break;  
    }  
    r->next = NULL;  
    printf("创建成功\n");  
    return head;                                               //返回头结点的地址  
}  
[cpp] view plain copy
void insert(DulNode *head, ElemType x, int i)       //在第i个位置上插入一个结点，并且结点的data为x  
{  
    DulNode *p, *r;  
    p = (DulNode *)malloc(sizeof(DulNode));                //建立这个结点   
    judgement_NULL(p);  
    p->data = x;  
    if (i == 1)                                               //考虑第一个结点的情况  
    {  
        p->next = head->next;  
        head->next->prior = p;  
        head->next = p;  
        p->prior = head;  
        printf("插入成功\n");  
    }  
    else  
    {  
        r = head->next;  
        while (r != NULL)                       //找到这个结点  
        {  
            if (i == 1)  
                break;  
            r = r->next;  
            i--;  
        }  
        if (r == NULL)  
            printf("没有这个结点\n");  
        else                                                        //如果这个结点存在  
        {  
            r->prior->next = p;  
            p->prior = r->prior;  
            p->next = r;  
            r->prior = p;  
            printf("插入成功\n");  
        }  
    }  
}  
[cpp] view plain copy
void delete_element(DulNode *head, ElemType x)    //删除链表中所有的X元素  
{  
    DulNode *p, *r;  
    int flag = 0;  
    if (head->next == NULL)                         //考虑链表为空的情况  
        printf("链表下溢\n");  
    else  
    {  
        p = head->next;  
        while (p != NULL)  
        {  
            if (p->data == x)  
            {  
                flag++;  
                r = p;  
                p = p->next;  
                r->prior->next = r->next;  
                r->next->prior = r->prior;  
                free(r);  
                r = NULL;  
            }  
            else  
                p = p->next;  
        }  
        if (flag == 0)  
            printf("没找到该元素\n");  
        else  
            printf("共删除%d个\n", flag);  
    }  
}  
void delete_place(DulNode *head, int i)      //删除指定位置的结点  
{  
    DulNode *p;  
    if (head->next == NULL)  
        printf("链表下溢\n");  
    else  
    {  
        p = head->next;  
        while (p != NULL)                            //先找到这个位置  
        {  
            if (i == 1)  
                break;  
            p = p->next;  
            i--;  
        }  
        if (p == NULL)  
            printf("没有此位置\n");  
        else  
        {  
            p->prior->next = p->next;  
            p->next->prior = p->prior;  
            free(p);  
            p = NULL;  
            printf("删除成功\n");  
        }  
    }  
}  
[cpp] view plain copy
void find_element(DulNode *head, int i)               //查找第i个结点上的data，找到并输出  
{  
    DulNode *p;  
    if (head->next == NULL)  
        printf("链表下溢\n");  
    else  
    {  
        p = head->next;  
        while (p != NULL)  
        {  
            if (i == 1)  
                break;  
            p = p->next;  
            i--;  
        }  
        if (p == NULL)  
            printf("没有该结点\n");  
        else  
            printf("结点元素：%d\n", p->data);  
    }  
}  
[cpp] view plain copy
void find_place(DulNode *head, ElemType x)       //找到链表中所有data为x的结点，并输出结点位置  
{  
    DulNode *p;  
    int i = 0;  
    int flag = 0;  
    if (head->next == NULL)  
        printf("链表下溢\n");  
    else  
    {  
        p = head->next;  
        while (p != NULL)  
        {  
            i++;  
            if (p->data == x)  
            {  
                flag++;  
                printf("此元素的结点位置：%d\n",i);  
            }  
            p = p->next;  
        }  
        if (flag == 0)  
            printf("链表中没有该结点\n");  
    }  
}  
[cpp] view plain copy
void length(DulNode *head)              //求链表长度  
{  
    DulNode *p = head->next;  
    int len = 0;  
    if (head->next == NULL)  
        printf("链表长度为：%d\n", len);  
    else  
    {  
        while (p != NULL)                 
        {  
            len++;  
            p = p->next;  
        }  
        printf("链表长度：%d\n", len);  
    }  
}  

[cpp] view plain copy
void output_order(DulNode *head)        //正向打印链表  
{  
    DulNode *p = head->next;  
    if (head->next == NULL)  
        printf("链表为空");  
    else  
    {  
        printf("顺序打印链表：");  
        while (p != NULL)  
        {  
            printf("%d ", p->data);  
            p = p->next;  
        }  
    }  
    printf("\n");  
}  
[cpp] view plain copy
void output_back(DulNode *head)         //反向打印链表  
{  
    DulNode *p;  
    if (head->next == NULL)  
        printf("链表为空");  
    else  
    {  
        printf("逆序打印链表：");  
        p = head->next;  
        while (p->next != NULL)                  //让p指向最后一个结点  
        {  
            p = p->next;  
        }  
        while (p != head)  
        {  
            printf("%d ", p->data);  
            p = p->prior;  
        }  
    }  
    printf("\n");  
}  
[cpp] view plain copy
void initslinklist(DulNode *head)                         //释放当前链表  
{  
    DulNode *p,*r;  
    p = head;  
    while (p != NULL)  
    {  
        r = p;  
        p = p->next;  
        free(r);  
        r= NULL;  
    }  
    head = NULL;  
    printf("初始化成功\n");  
}  
void sortrank(DulNode *head)  
{  
    DulNode *p, *r;  
    p = head->next;  
    ElemType tmp;  
    while (p != NULL)                //使用冒泡排序  
    {  
        r = head->next;  
        while (r->next != NULL)  
        {  
            if ((r->data) > (r->next->data))  
            {  
                tmp = r->data;  
                r->data = r->next->data;  
                r->next->data = tmp;  
            }  
            r = r->next;  
        }  
        p = p->next;  
    }  
    printf("排序成功\n");  
}  
int means()  
{  
    int m = 0;  
    while (1)  
    {  
        printf("请选择方式：");  
        scanf("%d", &m);  
        if (m == 1 || m == 2)  
            break;  
        printf("选择无效，请重新选择\n");  
    }  
    return m;  
}  
[cpp] view plain copy
//函数测试："twowaylinklist.c"  

#include"twowaylinklist.h"  

int main()  
{  
    DulNode *ret = NULL;  
    int n = 0;  
    int i = 0;  
    ElemType x;  
    printf("*********************************************\n");  
    printf("*********************************************\n");  
    printf("*1.CreatLinkList      2.Insert  *********\n");  
    printf("*3.Delete        4.Find   *********\n");  
    printf("*5.Length        6.Output  *********\n");  
    printf("*7.InitsLinkLinst    8.Sortrank  ********\n");  
    printf("*0.Exit          *********************\n\n\n");  

    while (1)  
    {  
        printf("请选择功能：");  
        scanf("%d", &n);  
        if (n == 0)                       //选择0直接退出  
        {  
            free(ret);                     //退出前先释放列表  
            exit(1);  
        }  
        if (ret == NULL)                     //如果ret为空，则首先建立链表  
        {  
            if (n == 1)  
            {  
                printf("创建链表以0作为结束标志\n");  
                ret = creat();  
            }  
            else  
                printf("请先建立链表\n");  
        }         
        else  
        {  
            switch (n)                       //选择剩下的功能  
            {  
            case 1:                        //当ret为空时才能建立链表  
                printf("当前链表未结束，请先初始化链表\n");  
                break;  
            case 2:  
                printf("请输入要插入的元素和位置：");  
                scanf("%d", &x);  
                scanf("%d", &i);  
                insert(ret, x, i);  
                break;  
            case 3:  
                printf("*1.delete_element     2.delete_place*\n");  
                if (means() == 1)  
                {  
                    printf("请输入要删除的元素：");  
                    scanf("%d", &x);  
                    delete_element(ret, x);  
                }  
                else  
                {  
                    printf("请输入要删除的结点：");  
                    scanf("%d", &i);  
                    delete_place(ret, i);  
                }  
                break;  
            case 4:  
                printf("*1.find_place         2.find_element*\n");  
                if (means() == 1)  
                {  
                    printf("请输入要查找的元素：");  
                    scanf("%d", &x);  
                    find_place(ret, x);  
                }  
                else  
                {  
                    printf("请输入要查找的位置：");  
                    scanf("%d", &i);  
                    find_element(ret, i);  
                }  
                break;  
            case 5:  
                length(ret);  
                break;  
            case 6:  
                printf("*1.output_order         2.output_back*\n");  
                if (means() == 1)  
                    output_order(ret);  
                else  
                    output_back(ret);  
                break;  
            case 7:                     //将当前链表释放  
                initslinklist(ret);  
                ret = NULL;  
                break;  
            case 8:  
                sortrank(ret);  
                break;  
            default:  
                printf("选择无效，请重新选择\n");  
                break;  
            }  
        }  
        n = 0;  
    }  
    system("pause");  
    return 0;  
}
夏天的呆子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向单链表
weixin_34342992的博客
04-15 69
//函数声明：#include"twowaylinklist.h" #define_CRT_SECURE_NO_WARNINGS1 #include<stdio.h> #include<stdlib.h> typedefintElemType; typedefstructDulNode { structDulNode*prior...
数据结构——双向单链表
qq_39628738的博客
02-21 674
首先搞清楚双向链表和单链表的区别： 双向链表比单链表多出一个指针域，保存上一个结点的地址 双向链表：和单链表相比，双向链表有两个指针域，既可以右边的结点地址（后继），也可以保存左边的结点地址（前驱） 如果是一个空的双向链表，则它的next和prior同时指向NULL即可 双向链表的结构体设计： //双向链表结构体设计： typedef int ELEM_TYPE; typedef struct Dlist { ELEM_TYPE data;//数据域 保存有效值 st
单链表与双向链表
drunkpragrammer的博客
12-08 433
单链表 链表中的数据是以节点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 以"结点的序列"表示线性表称作线性链表(单链表) 单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结
单/双向链表浅谈
daydreamqun的博客
04-10 639
链表浅谈 再一次接触链表发现链表已经比最初很容易上手了，第二次学链表让我觉得链表最重要的是它的思想，代码是属于理解了就会很容易上手。 So，谈谈思想。 一.单向链表 单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值NULL。 单向链表只可向一个方向遍历。 查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以...
java实现单链表、双向链表
09-02
本示例中，我们分别讨论了两种类型的链表：单链表和双向链表。 单链表由一系列节点组成，每个节点包含一个数据字段和一个指向下一个节点的引用。在Java中，我们可以创建一个`Node`类来表示单链表的节点： ```java ...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
python版本单链表实现代码
09-20
在本文中，我们将探讨如何在Python中实现单链表。单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的引用（在Python中通常称为指针）。在Python中，由于没有原生的指针概念，...
C语言实现单链表实现方法
12-31
C语言实现单链表实现方法 链表和我们之前实现过的顺序表一样，都是简单的数据结构，链表分为单向链表、双向链表、循环链表。而单向链表又分为两种实现方法，一种为带头节点的单链表，一种为不带头节点的单链表。我们...
php单链表实现代码分享
10-22
在PHP中，单链表是一种基础的数据结构，用于存储一系列有序的数据。单链表的特点是每个节点包含...熟悉单链表的实现可以帮助开发者更有效地处理动态数据集合，特别是在内存管理或者需要高效插入和删除操作的场景下。
数据结构5——单链表与双链表（超全）
zxdznyy的博客
06-06 2420
文章目录前言一、链表1.单链表2.双链表二、单链表1.成员变量2.getSize()和isEmpty()3.链表的虚拟头节点1.什么是链表的虚拟头结点2.代码4.链表的基础方法1.向链表中添加节点2.链表中删除节点3.找到index处的元素4.查找是否有该元素5.知索引获取元素5.打印链表5.整体的代码实现三.双链表1.双链表的结构2.双链表的成员变量3.与单链表的不同之处1.双链表中增加元素2.双链表中删除元素4.整体代码实现总结 前言 本节讲述的是单链表与双链表基础方法的原理及实现，双链表将在单链表的
数据结构--链表（单链表、双向单链表、单向循环链表）
ayu6_1的博客
12-05 1128
单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域 value）和一个链接域(或者称为指针域next)。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 单向链表图示 表元素域elem用来存放具体的数据。 链接域next用来存放下一个节点的位置（python中的标识） 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 链表的基本元素有： 节点：每个节点有两个部分，左边部分称为值域，用来存放用户数据；右边部分称为指针
简单易懂的C语言实现双向链表代码
zhang197093的博客
12-01 1万+
链表是一种常见的数据结构，链表中的每一个节点都保存了上一个或下一个元素的位置，所以表现为增删元素效率较高，查找元素效率较低 简单的C语言实现代码： #include #include #include //节点结构体，每个节点分别保存了一个指向前一个节点的指针和指向后一个节点的指针，以及保存数据的指针 struct _node{ void *prevNode; void
创建双向链表（详解）
热门推荐
Frank的博客
11-25 6万+
双向链表操作 在学习了单链表之后，就顺带学习了双链表的操作。 什么是双链表？ 双链表顾名思义，就是链表由单向的链变成了双向链。 使用这种数据结构，我们可以不再拘束于单链表的单向创建于遍历等操作，大大减少了在使用中存在的问题。 在单链表中，我们有一个数据域，还有一个指针域，数据域用来存储相关数据，而指针域则负责链表之间的“联系”。 而在双向链表中，我们需要有两个指针域，一个负责向后连接，一个负...
双向链表与循环链表
wyqwilliam的博客
09-16 1万+
双向链表 单链表的一个优点是结构简单，但是它也有一个缺点，即在单链表中只能通过一个结点的引用访问其后续结点，而无法直接访问其前驱结点， 要在单链表中找到某个结点的前驱结点，必须从链表的首结点出发依次向后寻找，但是需要Ο(n)时间。 为此我们可以扩展单链表的结点结构，使得通过一个结点的引用，不但能够访问其后续结点，也可以方便的访问其前驱结点。 扩展单链表结点结构的方法是，在单链表结点结构中新增加一...
单向链表与双向链表
nodeee的博客
12-09 2938
单向链表 单向链表的特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 列表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。 双向链表 双向链表的每个数据结点中都有两个指针，分别指向前面的rlink和后面的lli...
C——(单向、单向循环、双向、双向循环)链表学习总结
C_Aya的博客
07-25 1万+
这段时间一边看书一边把链表的知识总结了一下，并且画了示意图来帮助理解。主要是单向链表，单向循环链表，双向链表，双向循环链表四个部分，每个部分都包括了初始化，创建，插入，删除的基本操作，并总结了各个操作的核心代码。抽空可以看看Linux内核自带的链表(list.h)写法，增进学习。以下的链表均是不操作头节点的。一、单向链表1.单向链表：链式的存储结构，在逻辑上是连续的，每次通过一个指针来指向下一个节点
C语言实现单链表 && 双向链表
m0_64240499的博客
08-03 665
单链表&&双向链表
图解单向链表、双向链表
cb_lcl的博客
07-26 3735
背景： 之前对单向链表、双向链表之间的结构一直理解的有些混乱，然后就各种百度、google查资料，最后在知乎里看到一篇专栏，一看里面的图就明白是咋回事了。        ...
C++实现单链表：结点描述与初始化
理解这些概念对于理解和实现更复杂的数据结构和算法至关重要，如双向链表、循环链表以及更高级的操作，如查找、排序和合并链表等。在实际编程中，链表被广泛用于各种应用，例如缓存管理、图形处理、队列和栈的实现等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值