数据结构（10）线性表之双向链表

最新推荐文章于 2023-08-01 17:33:40 发布
最新推荐文章于 2023-08-01 17:33:40 发布
阅读量1k 收藏 2
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 线性表 双向链表 算法 实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YuYunTan/article/details/50903595
版权

导言

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双向表的结点有两个指针域，一个是其直接前驱，一个是其直接后继。

双向链表

存储结构

typedef struct DuLNode
{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode,*DuLinkList;

双向链表也有循环表形式
双向链表中，若d指向表中的某一个结点的指针（即d为DuLinkList型变量），则显然有：

d⟶next⟶prior=d⟶prior⟶next=d

双向链表的示例图

这里写图片描述

双向链表操作，如ListLength、GetElem和LocateElem等仅需要涉及一个方向的指针，则它们的算法描述与线性表的操作相同，但插入、删除却有很大不同，需要改变两个方向上的指针。

示例

这里写图片描述

双向链表取得元素算法

Status GetElemP_DuL(DuLinkList va, int i, ElemType *e) {
    // L为带头结点的单链表的头指针。
    // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    DuLinkList p;
    p = va->next;
    int j = 1;  // 初始化，p指向第一个结点，j为计数器
    while (p != va && j<i) {  //顺指针向后查找，直到p指向第i个元素或p为空
        p = p->next;
        ++j;
    }
    if (p == va || j > i) return ERROR;  // 第i个元素不存在
    *e = p->data; /* 取第i个元素 */
    return OK;
} // GetElem_L

双向表插入算法


Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { //算法2.18
  // 在带头结点的双链循环线性表L的第i个元素之前插入元素e，
  // i的合法值为1≤i≤表长+1。
  DuLinkList p,s;
  if (!(p = GetElemP_DuL(L, i)))  // 在L中确定第i个元素的位置指针p
    return ERROR;                 // p=NULL, 即第i个元素不存在
  if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
    return ERROR;
  s->data = e;
  s->prior = p->prior;
  p->prior->next = s;
  s->next = p;
  p->prior = s;
  return OK;
} // ListInsert_DuL

双向表删除算法

Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e) {//算法2.19
  // 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
  DuLinkList p;
  if (!(p = GetElemP_DuL(L, i)))  // 在L中确定第i个元素的位置指针p
    return ERROR;                 // p=NULL, 即第i个元素不存在
  e = p->data;
  p->prior->next = p->next;
  p->next->prior = p->prior;
  free(p);    
  return OK;
} // ListDelete_DuL

双向链表的实现源码

//所有定义
#define   LIST_INIT_SIZE        100
#define   LISTINCREMENT         10
#define   OK                    1
#define   ERROR                 0
#define   OVERFLOW             -2
#define   TRUE                  1
#define   FALSE                 0
typedef   int   Status;//为了方便算法可用性，算法的Status可以通过这里可改
typedef char ElemType;//为了输出的可用性，数据的ElemType可以通过这里更改
#include <iostream>
using namespace std;

typedef struct DuLNode
{
    ElemType data;
    struct DuLNode *prior;
    struct DuLNode *next;
}DuLNode, *DuLinkList;

void InitList(DuLinkList &L)
{ /* 产生空的双向循环链表L */
    L = (DuLinkList)malloc(sizeof(DuLNode));
    if (L)
        L->next = L->prior = L;
    else
        exit(OVERFLOW);
}

void DestroyList(DuLinkList L)
{
    DuLinkList q, p = L->next; /* p指向第一个结点 */
    while (p != L) /* p没到表头 */
    {
        q = p->next;
        free(p);
        p = q;
    }
    free(L);
    L = NULL;
}
void ClearList(DuLinkList L) /* 不改变L */
{
    DuLinkList q, p = L->next; /* p指向第一个结点 */
    while (p != L) /* p没到表头 */
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = L->prior = L; /*头结点的两个指针域均指向自身 */
}
Status ListEmpty(DuLinkList L)
{ /* 初始条件：线性表L已存在*/
  if(L->next == L && L->prior == L)
    return TRUE;
  else
    return FALSE;
 }
int ListLength(DuLinkList L)
{ /* 初始条件：L已存在。操作结果： */
    int i = 0;
    DuLinkList p = L->next; /* p指向第一个结点 */
    while (p != L) /* p没到表头 */
    {
        i++;
        p = p->next;
    }
    return i;
}
Status GetElemP_DuL(DuLinkList va, int i, ElemType *e) {
    // L为带头结点的单链表的头指针。
    // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    DuLinkList p;
    p = va->next;
    int j = 1;  // 初始化，p指向第一个结点，j为计数器
    while (p != va && j<i) {  //顺指针向后查找，直到p指向第i个元素或p为空
        p = p->next;
        ++j;
    }
    if (p == va || j > i) return ERROR;  // 第i个元素不存在
    *e = p->data; /* 取第i个元素 */
    return OK;
} // GetElem_L
int LocateElem(DuLinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{ /* 初始条件：L已存在，compare()是数据元素判定函数 */
    /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
    /* 若这样的数据元素不存在，则返回值为0 */
    int i = 0;
    DuLinkList p = L->next; /* p指向第1个元素 */
    while (p != L)
    {
        i++;
        if (compare(p->data, e)) /* 找到这样的数据元素*/
            return i;
        p = p->next;
    }
    return 0;
}
Status equal(ElemType c1, ElemType c2)
{ /* 判断是否相等的函数，Union()用到 */
    if (c1 == c2)
        return TRUE;
    else
        return FALSE;
}

Status PriorElem(DuLinkList L, ElemType cur_e, ElemType *pre_e)
{ /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
    /* 否则操作失败，pre_e无定义 */
    DuLinkList p = L->next->next; /* p指向第2个元素 */
    while (p != L) /* p没到表头 */
    {
        if (p->data == cur_e)
        {
            *pre_e = p->prior->data;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE;
}
Status NextElem(DuLinkList L, ElemType cur_e, ElemType *next_e)
{ /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
    /* 否则操作失败，next_e无定义 */
    DuLinkList p = L->next->next; /* p指向第2个元素 */
    while (p != L) /* p没到表头 */
    {
        if (p->prior->data == cur_e)
        {
            *next_e = p->data;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE;
}
DuLinkList GetElemP_DuL(DuLinkList va, int i) {
    // L为带头结点的单链表的头指针。
    // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    DuLinkList p;
    p = va->next;
    int j = 1;  // 初始化，p指向第一个结点，j为计数器
    while (p != va && j<i) { //顺指针向后查找，直到p指向第i个元素或p为空
        p = p->next;
        ++j;
    }
    if (p == va && j<i) return NULL;  // 第i个元素不存在
    else return p;
} // GetElem_L
Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { //算法2.18
    // 在带头结点的双链循环线性表L的第i个元素之前插入元素e，
    // i的合法值为1≤i≤表长+1。
    DuLinkList p, s;
    if (!(p = GetElemP_DuL(L, i)))  // 在L中确定第i个元素的位置指针p
        return ERROR;                 // p=NULL, 即第i个元素不存在
    if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
        return ERROR;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;
    return OK;
} // ListInsert_DuL
Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e) {//算法2.19
    // 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
    DuLinkList p;
    if (!(p = GetElemP_DuL(L, i)))  // 在L中确定第i个元素的位置指针p
        return ERROR;                 // p=NULL, 即第i个元素不存在
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;
} // ListDelete_DuL
void ListTraverse(DuLinkList L, void(*visit)(ElemType))
{ /* 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit() */
    DuLinkList p = L->next; /* p指向头结点 */
    while (p != L)
    {
        visit(p->data);
        p = p->next;
    }
}
void visit(ElemType elem)
{
    cout << elem << " ";
}

int main()
{
    //本程序说明，是在VS2013中运行的，若是其他地方无法运行，建议修改代码
    //程序声明
    cout << "***************************************************************************" << endl;
    cout << "                   《数据结构》<C语言版本>严蔚敏 吴伟名 编著              " << endl;
    cout << "                                编写年月2016年3月                         " << endl;
    cout << "                                 编写者:YuYunTan                          " << endl;
    cout << "                                      双向链表                            " << endl;
    cout << "***************************************************************************" << endl;
    DuLinkList A=NULL;
    InitList(A);
    ListInsert_DuL(A, 1, 'A');
    ListInsert_DuL(A, 2, 'B');
    ListInsert_DuL(A, 3, 'C');
    ListInsert_DuL(A, 4, 'D');
    ListInsert_DuL(A, 5, 'F');
    cout << "List A = < ";
    ListTraverse(A, visit);
    cout << ">" << endl;
    ElemType pa,prior_a,a_next;
    GetElemP_DuL(A, 3, &pa);
    cout << "第三个元素为"<< pa <<endl;
    PriorElem(A, pa, &prior_a);
    NextElem(A, pa, &a_next);
    cout << pa << "的直接前驱是"<<prior_a << endl;
    cout << pa << "的直接后继是" << a_next << endl;
    cout << a_next << "在A中的位序是" << LocateElem(A, a_next, equal) << endl;
    cout << "清空表A" << endl;
    ClearList(A);
    cout << "List A = < ";
    ListTraverse(A, visit);
    cout << ">" << endl;

    DestroyList(A);

    system("pause");
    return 0;

}

运行结果

这里写图片描述

双向链表到这里为止~

YuYunTan
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构】——链式存储结构之双向链表
维欣~fighting✔
04-12 3202
文章目录一、双向链表存储结构1、了解2、定义3、结构二、双链表的结构设计三、初始化四、插入操作1、开辟新结点pnewnode2、分析3、头插:将元素插入头结点之后3、尾插：将元素插入整个链表的尾部4、获取当前的链表长度：判断位置是否合理5、按位置插入（pos为插入位置）四、删除操作1、判空2、头删：删除头结点的下一个结点3、尾删：删除尾部结点4、按位置删除五、查询单链表 一、双向链表存储结构 1、...
数据结构与算法基础篇3-线性表-双向链表的基本操作C++
2301_76210003的博客
05-07 244
单链表的局限性：无法逆向检索，有时候会不太方便，我们在单链表每个结点里增加一个指向其直接前驱的指针域prior，这样就形成了两条方向不同的链，故称为双向链表。
双向链表.doc循环链表的存储结构
03-21
双向链表.doc复习线性链表的存储结构循环链表的存储结构
双向链表存储结构
luoage的专栏
11-03 4449
#include #include using namespace std; // 线性表的双向链表存储结构 struct node{     int data;     node *prev,*next; // 声明      }; // 双向链表存储 class doubleLink{ private:     node *eleStart,*eleEnd;     node* node
链式存储结构-双向链表
测试
06-28 251
目录 链式存储结构-双向链表 链式存储结构-双向链表 //duolist.c #include <stdlib.h> #include <stdio.h> //wuy@farsight.cn // //类型 typedef struct nod...
双链表的存储结构
qq_57484399的博客
10-03 1619
首先 建立头结点。
线性表双向链表存储的实现
12-25
单链表结构定义、初始化、插入元素、删除元素、遍历显示、释放空间，易懂，学习。
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构线性表双向链表多项式PPT学习教案.pptx
10-03
数据结构中的线性表是一种基础的数据组织形式，而双向链表是线性表的一种扩展，它在单链表的基础上增加了指向前后两个元素的指针，从而提供了双向的遍历能力。双向链表的每个节点通常包含三个部分：数据域、前驱指针...
数据结构之线性表——双向链表
ds_kuen的博客
05-11 534
1 双向链表描述
《大话数据结构》7一文学会数据结构中的双向链表存储结构（概念，实例，代码）
weixin_45594172的博客
03-17 397
《大话数据结构》7一文学会数据结构中的双向链表存储结构（概念，实例，代码）
双向链表的存储设计与实现(C语言版本)
小强博客
05-17 3481
双向链表的插入操作：双向链表的删除操作：//DLinkList.h #ifndef _DLINKLIST_H_ #define _DLINKLIST_H_ //双向链表的存储结构 //结点中包含后继结点的地址的指针域可以理解为指向下一个结构体(结点) //(这里不包含数据域,是实现了 链表的api(链表的算法) 和 具体的数据分离) typedef struct _tag_DLinkListNo...
线性表--链式存储结构--双向链表
hongcaixia的博客
03-29 916
双向链表 一、双向链表结构 双向链表结点结构 typedef struct DualNode { ElemType data; struct DualNode *prior; //前驱结点 struct DualNode *next; //后继结点 } DualNode, *DuLinkList; 既然单链表可以有循环链表，那么双向链表当然也可以...
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3689
双向链表
单链表的读取操作GetElem
litang318的博客
03-23 3373
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
单链表操作实现getelem_线性表的实现和操作
weixin_28864057的博客
12-29 2463
1.顺序表(顺序存储)对于非空的线性表和线性结构，有以下特点:1.存在唯一的一个被称作”第一个“的数据元素2.存在唯一一个被称作”最后一个“的数据元素3.除了第一个之外，结构中的每个数据元素均有一个前驱4.除了最后一个之外，结构中的每个数据元素都有一个后继。顺序链表的实现:0.定义最大长度#define MAXSIZE 100 #define OK 1 #define ERROR 0创建表结构//...
数据结构（C语言） 双向链表源码
m0_48446168的博客
10-13 503
双向链表 （一）定义 typedef struct DuLNode{ ElemType data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinkList; （二）增 ListInsert_DuL Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { // 在带头结点的双链循环线性表L的第i个元素...
双向链表及其用法
热门推荐
5431的专栏
04-17 1万+
一、双向链表的定义 二、双向链表的存储结构 三、双向链表的实现与操作
数据结构与算法(3)--双向链表存储结构
小朱的博客
05-11 512
双向链表存储结构 #include<cstdio> #define Elemtype int typedef struct DNode{ Elemtype data; Struct DNode *prior,*next; }DNode,*DLinkList; //初始化 (头插法) DLinkList InitDLinkList(DLinkList &L) { L =...
数据结构：线性表与双向循环链表类定义
"这篇内容主要介绍了数据结构中的线性表，特别是双向循环链表类的定义。线性表是一种包含n个数据元素的有限序列，其中每个元素除了第一个之外都有唯一的直接前驱，除了最后一个之外都有唯一的直接后继。这种结构在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YuYunTan

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

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

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

打赏作者

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

抵扣说明：

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

余额充值