双向链表基本操作（代码实现）

最新推荐文章于 2024-07-18 13:14:30 发布
最新推荐文章于 2024-07-18 13:14:30 发布
阅读量614 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52548565/article/details/122248653
版权

此代码含自定义包
双向链表即，节点有前驱节点，后继节点，结构如下

typedef struct DNode{
    DataType Data;
    struct DNode* pre;
    struct DNode* next;
}DNode,*DLinkList;

双向链表基本操作如下（及下包中所含）
程序头文件（head.h）

#ifndef HEAD_H_INCLUDED
#define HEAD_H_INCLUDED
#include <bits/stdc++.h>

typedef int DataType;
typedef struct DNode{
    DataType Data;
    struct DNode* pre;
    struct DNode* next;
}DNode,*DLinkList;

void InitList(DLinkList* Phead,DLinkList* Ptail);//建立双向链表的头，尾节点.
bool DList_Empty(DLinkList Phead);//判断双向链表是否为空
void CreatFrom_Head(DLinkList Phead);//头插法给双向链表加入成员
void CreatFrom_Fail(DLinkList Pfail);//尾插法给双向链表加入成员
void DList_Insert(DLinkList Phead,DLinkList Ptail,int locate,DataType data);//在位于locate的成员后插入data
int DList_length(DLinkList Phead,DLinkList Ptail);//求链表长度
DNode* Get(DLinkList Phead,DLinkList Ptail,int n);//查找第n个成员
int Locate(DLinkList Phead,DLinkList Ptail,int data);//查找成员的位置
void DList_Del(DLinkList Phead,DLinkList Ptail,DataType data);//删除在成员data
void DList_Print(DLinkList Phead,DLinkList Ptail);//遍历双向链表
void DList_Dstory(DLinkList Phead);//销毁链表

#endif // HEAD_H_INCLUDED

对操作的实现
程序文件（head.cpp）

#include <bits/stdc++.h>
using namespace std;

typedef int DataType;//成员类型

typedef struct DNode{
    DataType Data;
    struct DNode* pre;//指向前驱节点
    struct DNode* next;//指向后继节点
}DNode,*DLinkList;

void InitList(DLinkList* Phead,DLinkList* Ptail)//双向节点初始化
{
    //Phead是三级指针，指向结构体的是二级指针，所以程序中要*Phead。
    *Phead = (DLinkList)malloc(sizeof(DNode));
    *Ptail = (DLinkList)malloc(sizeof(DNode));
    if((*Phead)==NULL||(*Ptail)==NULL)
            cout<<"双向链表建立失败"<<endl;
    else
    {
        (*Phead)->pre = (*Phead)->next = NULL;
        (*Ptail)->pre = (*Ptail)->next = NULL;
        (*Phead)->next = (*Ptail);
        (*Ptail)->pre = (*Phead);
    }
}

bool DList_Empty(DLinkList Phead)//判断双向链表是否为空
{
    if(Phead->next->next == NULL)
        return false;
    else
        return true;

}

void CreatFrom_Head(DLinkList Phead)//头插法插入成员
{
    int data;
    DNode* p;
    while((cin>>data)!=0&&data!=-1)
    {
        getchar();
        p = (DLinkList)malloc(sizeof(DNode));
        p->Data = data;
        //指针交换核心代码。
        p->next = Phead->next;
        Phead->next->pre = p;
        Phead->next = p;
        p->pre = Phead;
    }
}

void CreatFrom_Fail(DLinkList Pfail)//尾插法插入成员
{
    int data;
    DNode* p;
    while((cin>>data)!=0&&data!=-1)
    {
        getchar();
        p = (DLinkList)malloc(sizeof(DNode));
        p->Data = data;
        //指针交换核心代码
        p->pre = Pfail->pre;
        Pfail->pre->next = p;
        Pfail->pre = p;
        p->next = Pfail;
    }
}

int DList_length(DLinkList Phead,DLinkList Ptail)//链表长度
{
    int i=0;
    DNode* p = Phead->next;
    while(p!=Ptail)
    {
        p = p->next;
        i++;
    }
    return i;
}

DNode* Get(DLinkList Phead,DLinkList Ptail,int n)//查找第n个成员
{
    int len = DList_length(Phead,Ptail);
    if(n>0&&n<=len)
    {
         int i=1;
         DNode* p = Phead->next;
         while(i<n)
         {
             p = p->next;
             i++;
         }
         return p;
    }
    else
    {
        return NULL;
    }
}

void DList_Insert(DLinkList Phead,DLinkList Ptail,int locate,DataType data)//在locate位置插入成员
{
    DLinkList Ph = Get(Phead,Ptail,locate)->pre;//调用Get()找到成员
    DLinkList p = (DLinkList)malloc(sizeof(DNode));
    if(Ph!=NULL)
    {
        p->Data = data;
        //插入元素核心代码
        p->next = Ph->next;
        Ph->next->pre = p;
        Ph->next = p;
        p->pre = Ph;
    }
    else
        cout<<"插入位置不合法"<<endl;

}

void DList_Del(DLinkList Phead,DLinkList Ptail,DataType data)//删除成员data
{
    DLinkList p = Phead->next;
    while(p->Data!=data&&p->next!=NULL)//找到data位置
    {
        p = p->next;
    }
    if(p->Data==data)//删除该节点并且释放空间
    {
        DLinkList h = p->pre;
        DLinkList f = p->next;
        h->next = f;
        f->pre = h;
        free(p);
    }
    else
         cout<<data<<"不在该链表中"<<endl;

}

void DList_Print(DLinkList Phead,DLinkList Ptail)//遍历双向链表
{
    cout<<"双向链表的成员有(从头开始遍历): ";
    DNode* ph = Phead->next;
    DNode* pt = Ptail->pre;
    while(ph->next!=NULL)
    {
        cout<<ph->Data<<" ";
        ph = ph->next;
    }
    cout<<"\n双向链表的成员有(从尾开始遍历): ";
    while(pt->pre!=NULL)
    {
        cout<<pt->Data<<" ";
        pt = pt->pre;
    }
    cout<<endl;
}

int Locate(DLinkList Phead,DLinkList Ptail,int data)//查找成员data的位置
{
    int i=1;
    DLinkList p = Phead->next;
    while(p->Data!=data&&p->next!=NULL)
    {
        p = p->next;
        i++;
    }
    if(p->next==NULL)
    {
        cout<<data<<"没在该链表中"<<endl;
        return NULL;
    }
    else
        return i;
}

void DList_Dstory(DLinkList Phead)//销毁链表
{
    DLinkList p = Phead;
    DLinkList q;
    while(p!=NULL)
    {
        q = p;
        p = p->next;
        free(q);
    }
}

测试程序如下
程序文件（main.cpp）

#include <bits/stdc++.h>
#include "head.h"
using namespace std;
int main()
{
    int step;
    DLinkList head,tail;
    InitList(&head,&tail);//建立双向链表的头尾节点
    cout<<"*****************************"<<endl;
    cout<<"链表建立完毕，请选择指令"<<endl;
    cout<<"*****************************"<<endl;
    cout<<"-1 :结束操作\n"<<"1  :头插法插入元素\n"<<"2  :尾插法插入元素\n"<<"3  :插入操作"<<endl;
    cout<<"4  :删除操作\n"<<"5  :遍历该链表\n"<<"6  :求表长操作\n"<<"7  :按位置查找成员"<<endl;
    cout<<"8  :按值查找位置\n"<<"9  :判断链表是否为空\n"<<"0  :销毁链表"<<endl;
    cout<<"*****************************"<<endl;
    cout<<"请输指令: ";
    while((cin>>step!=0)&&step!=-1)
    {
        if(step==1)
        {
            cout<<"请输入插入的成员，空格分割，”-1“表示结束"<<endl;
            CreatFrom_Head(head);
        }
        else if(step==2)
        {
            cout<<"请输入插入的成员，空格分割，”-1“表示结束"<<endl;
            CreatFrom_Fail(tail);
        }
        else if(step==3)
        {
            int locate,data;
            cout<<"请输入插入成员"<<endl;
            cin>>data;
            cout<<"输入插入位置"<<endl;
            cin>>locate;
            DList_Insert(head,tail,locate,data);
        }
        else if(step==4)
        {
            int locate;
            cout<<"请输入需要删除成员"<<endl;
            cin>>locate;
            DList_Del(head,tail,locate);
        }
        else if(step==5)
        {
            DList_Print(head,tail);
        }
        else if(step==6)
        {
            int len = DList_length(head,tail);
            cout<<"双向链表的长度为"<<len<<endl;
        }
        else if(step==7)
        {
            int locate;
            DLinkList p;
            cout<<"请输入要找成员的位置"<<endl;
            cin>>locate;
            p = Get(head,tail,locate);
            if(p==NULL)
                cout<<"位置选取不合法"<<endl;
            else
                cout<<"该位置的成员是"<<p->Data<<endl;
        }
        else if(step==8)
        {
            int data;
            cout<<"请输入需要查找的成员值"<<endl;
            cin>>data;
            data = Locate(head,tail,data);
            cout<<"该成员的位置为："<<data<<endl;
        }
        else if(step==9)
        {
            if(DList_Empty(head)) cout<<"双向链表不为空"<<endl;
            else cout<<"空链表"<<endl;
        }
        else if(step==0)
        {
            DList_Dstory(head);
            cout<<"链表被销毁"<<endl;
        }
        cout<<"请输指令: ";
    }
    cout<<"结束命令";
}

测试结果如下
在这里插入图片描述
在这里插入图片描述

SNUT —zjr
关注
专栏目录
Go实现双向链表的示例代码
09-18
// 以下是双向链表的基本操作函数，例如 AddToHead, AddToTail, RemoveNode 等 ``` 在使用双向链表时，应考虑其优缺点。双向链表增加了对前驱节点的指针，使得查找前驱节点的操作变得简单，但它也增加了空间开销，...
【数据结构】双向链表（带头双向循环链表）——超详细代码
qq_59702185的博客
08-15 2082
在上一篇文章我们已经介绍了链表的分类，链表的种类非常多，分为带头还是不带头、单向的还是多向的、单向还是双向循环……上一节我们学习了不带头单向的不循环的链表，这一节，我们主要实现带头双向循环的链表。如果我们把这两种结构的链表掌握的话，那么所有类型的链表我们都可以自己实现了带头双向链表有一个数据域和两个指针域。指针域一个是前驱指针，指向前一个节点，一个是后继指针，指向后一个节点。//前驱节点 struct ListNode * next;//后继节点 LTDataType data;//数据域 };...
数据结构之双链表（c语言附完整代码)
m0_62795460的博客
11-04 2362
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。声明双链表typedef struct DNode //定义双链表结点类型 {//数据域 struct DNode * prior;//指向前驱结点 struct DNode * next;//指向后继结点 } DLinkNode;注意：本文章讨论的双链表是带头结点的双链表。
【数据结构】双向链表及其基本操
Z1tai的博客
11-10 1208
双向链表是一种常见的线性数据结构，它与单向链表相比具有双向遍历的优势。除了拥有指向后继节点的指针外，双向链表还拥有指向前驱节点的指针。这使得在双向链表中可以更有效地实现从后往前的遍历，而不像单向链表那样需要重新遍历整个链表。在某些场景下，双向链表能够更加高效地解决问题。
实现双链表的基本操作（c语言）
qq_63152286的博客
02-27 4168
介绍双链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、实现双链表的具体操作 定义双链表元素 创建链表 ①头插法 ②尾插法 插入结点 删除结点 查找结点 销毁双链表 打印双链表
【数据结构】双向链表的实现
adcxhw的博客
04-07 1486
又是一篇万字文章，建议收藏。
C++自实现双向链表的基本操作
12-01
1、本文详细描述了C++语言双向链表相关的概念和学习心得。2、通过详细示例，让读者更直观地阅读，更清晰的理解。3、示例代码可直接复制，编译后可直接运行...5、相信看完此文，你必定对双向链表的相关操作了如指掌了。
C++ 构造双向链表的实现代码
09-05
本文将深入探讨如何使用C++来实现一个双向链表，包括链表节点的定义、链表类的构建以及链表的各种操作，如插入元素、输出链表元素和获取链表大小。 首先，我们需要定义一个双向链表的节点结构体。这个结构体包含三...
【超详细图解】菜鸡如何理解双向链表的python代码实现
12-20
以下是一些基本操作的Python代码实现： 1. **插入节点**： - 在链表头部插入节点： ```python def insert_at_head(self, val): new_node = Node(val, None, self.head) if self.head is not None: self.head....
实验二 链表基本操作的实现
12-18
在这个实验“链表基本操作的实现”中，我们将深入理解链表的概念，学习如何创建、插入、删除节点，以及进行其他基本操作。 链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据...
数据结构——双向链表的实现
zhoubancheng的博客
10-30 828
三、顺序表和双向链表的优缺点分析注意：双向链表又称带头双向循环链表这⾥的“带头”跟前⾯我们说的“头节点”是两个概念，实际前⾯的在单链表阶段称呼不严谨，但是为了同学们更好的理解就直接称为单链表的头节点。带头链表⾥的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨的”哨兵位”存在的意义：遍历循环链表避免死循环。双向链表每个节点储存一个有效数据+前驱指针+后继指针。
双向链表_代码实现
最新发布
2301_80682565的博客
07-18 476
在代码实现的专题：只有手撕代码 ：），附上重点注释；重要的环节，会配上相应的调试截图与运行截图以便理解与验证。
【数据结构】双链表完整代码实现
飞舞的蓝色雪花
11-21 727
本章主要总结双向链表的知识点，并在C++环境下对双向链表进行了实现。
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3559
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 4946
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
双向链表的基本操作-数据结构
小铅笔
09-07 631
简单的双向链表的基本操作，非循环双向链表。其实循环双向链表就是最后一个元素p-next=NULL改为p->next=L; 1.头插法建立，尾插法建立 DouLinklist HeadCreatList()DouLinklist TailCreatList() 2.插入元素 Statue InsertLink(DouLinklist &L,Statue n,Elemtype key)3.
双向链表
zheng_lan_fang的博客
09-09 390
双向链表 一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 操作 is_empty() 链表是否为空 length() 链表长度travel() 遍历链表add(item) 链表头部添加 append(item) 链表尾部添加 insert(pos,
双向链表的创建（C语言）
m0_59141303的博客
05-24 2985
双向链表的相对于单向链表，更加方便，应因为它指针域里有前面结点的地址。 // // Created by liujun on 2022/4/16. // #include <stdio.h> #include <stdlib.h> typedef struct data{ int num; //数据域：存放数据 struct data *prev; //前驱指针：指向前一个节点的地址 struct data *next; //
双链表的基本操作
qq_44631587的博客
03-03 2794
带头结点的双向循环链表 链表结构如下： 每个节点都有一个数据域和两个指针域，这两个指针分别指向链表的前驱节点和后继节点，头节点的前驱节点是链表的最后一个节点，链表最后一个节点的后继节点是头节点。 正因为如此，带头结点的双向循环链表没有空节点，在进行遍历时，循环条件也与单链表不同： 单链表用cur->next为空判断当前节点是否为最后一个节点，带头的双向循环链表则需判断cur->next是否等于头节点。 定义： typedef int DataType; typedef struct ListN
C语言实现双向链表：操作与源代码解析
这些基本操作构成了双向链表的基本操作集合，使得我们可以对链表进行创建、读取、修改和删除等操作，是理解和实现链表数据结构的关键。双向链表相比于单链表的优点在于可以从两个方向遍历，方便在链表中间进行插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值