双链表——双链表的定义及其基本操作（初始化、头插法尾插法建表、插入、查找、删除、判空等）

已于 2022-03-29 11:12:44 修改
阅读量2.2w 收藏 422
点赞数 64
分类专栏： 经典编程题——线性表 文章标签： 指针 链表 数据结构 算法
于 2021-04-18 14:34:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44162361/article/details/115819742
版权

文章目录

双链表的定义

 为什么引入双链表？

 单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。

 双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。

 双链表中结点类型的描述：

typedef struct DNode{
    int data;  //数据域
    struct DNode *prior,*next;  //前驱和后继指针
}DNode, *DLinkList;

双链表上的操作

初始化

 双链表与单链表一样，为了操作方便也可以加入头结点，那么初始化双链表其实就是定义一个头结点，然后将指针域置空。

在这里插入图片描述

//初始化
void InitList(DLinkList &L){
    L = (DNode *)malloc(sizeof(DLinkList));
    L->prior = NULL;
    L->next = NULL;
}

插入操作

  在双链表中p所指的结点之后插入结点*s，其指针的变化过程如下图所示：
插入操作
 实现代码：

//将x插入到双链表L中*p结点的下一个结点
void Insert(DLinkList &L, DNode *p, int x){
    DNode *s = (DNode *)malloc(sizeof(DNode));
    s->data = x;
    s->next = p->next;  //1
    p->next->prior = s; //2
    s->prior = p;  //3
    p->next = s; //4
}

 当然，插入操作的语句并不只有这一种顺序，但必须保证1和2两步必须在4步之前，否则*p的后继结点的指针就会丢掉，导致插入失败。


建立双链表

头插法建立双链表

 每次在头结点的后面插入新结点。

 实现代码：

//头插法建立双链表
DLinkList HeadInsert(DLinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        DNode *s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        if(L->next == NULL){
            s->next = NULL;
            s->prior = L;
            L->next = s;
        }else{
            s->next = L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
        cin>>x;
    }
    return L;
}

尾插法建立双链表

 每次在双链表的尾部插入新结点，为此，应该声明一个尾指针r并始终指向尾结点。

 实现代码：

//尾插法建立双链表
DLinkList TailInsert(DLinkList &L){
    InitList(L);
    DNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        s->next = NULL;
        s->prior = r;
        r->next = s;
        r = s;
        cin>>x;
    }
    return L;
}

遍历操作

 从单链表的第一个结点开始，依次遍历输出结点的数据直到最后一个结点。

 实现代码：

//遍历操作
void PrintList(DLinkList L){
    DNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

求双链表的长度

 从双链表的第一个结点开始，依次遍历每个结点，并计数，直到最后一个结点为止。

 实现代码：

//求双链表的长度
int Length(DLinkList L){
    DNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

查找操作

按值查找

 查找值x在L中的位置。与单链表的按值查找是一样的，不会用到前驱结点指针prior。

 实现代码：

//按值查找：查找x在L中的位置
DNode *LocateElem(DLinkList L, int x){
    DNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

按位查找

 查找在双链表L中第 i 个位置的结点。与单链表的按位查找是一样的，不会用到前驱结点指针prior。

 实现代码：

//按位查找：查找在双链表L中第i个位置的结点
DNode *GetElem(DLinkList L, int i){
    int j=1;
    DNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

删除操作

删除操作
 将双链表中的第 i 个结点删除。

 实现代码：

//删除操作:将双链表中的第i个结点删除
void Delete(DLinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    DNode *p = GetElem(L,i-1);
    DNode *q = p->next;
    p->next = q->next; //1
    q->next->prior = p; //2
    free(q);
}

判空操作

 判断双链表是否为空。

 实现代码：

//判空操作
bool Empty(DLinkList L){
    if(L->next == NULL){
        cout<<"L is null"<<endl;
        return true;
    }else{
        cout<<"L is not null"<<endl;
        return false;
    }
}

完整代码及实例

 完整代码：

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

typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode, *DLinkList;

//初始化
void InitList(DLinkList &L){
    L = (DNode *)malloc(sizeof(DLinkList));
    L->prior = NULL;
    L->next = NULL;
}

//遍历操作
void PrintList(DLinkList L){
    DNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

//求双链表的长度
int Length(DLinkList L){
    DNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

//头插法建立双链表
DLinkList HeadInsert(DLinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        DNode *s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        if(L->next == NULL){
            s->next = NULL;
            s->prior = L;
            L->next = s;
        }else{
            s->next = L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
        cin>>x;
    }
    return L;
}

//尾插法建立双链表
DLinkList TailInsert(DLinkList &L){
    InitList(L);
    DNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (DNode *)malloc(sizeof(DNode));
        s->data = x;
        s->next = NULL;
        s->prior = r;
        r->next = s;
        r = s;
        cin>>x;
    }
    return L;
}

//按值查找：查找x在L中的位置
DNode *LocateElem(DLinkList L, int x){
    DNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

//按位查找：查找在双链表L中第i个位置的结点
DNode *GetElem(DLinkList L, int i){
    int j=1;
    DNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到双链表L中*p结点的下一个结点
void Insert(DLinkList &L, DNode *p, int x){
    DNode *s = (DNode *)malloc(sizeof(DNode));
    s->data = x;
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
}

//删除操作:将双链表中的第i个结点删除
void Delete(DLinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    DNode *p = GetElem(L,i-1);
    DNode *q = p->next;
    p->next = q->next;
    q->next->prior = p;
    free(q);
}

//判空操作
bool Empty(DLinkList L){
    if(L->next == NULL){
        cout<<"L is null"<<endl;
        return true;
    }else{
        cout<<"L is not null"<<endl;
        return false;
    }
}


int main(){
    //尾插法建立双链表，并遍历单链表
    DLinkList L = TailInsert(L);
    cout<<"L: ";
    PrintList(L);
    
    DNode *p;
    //按值查找
    p = LocateElem(L,2);
    cout<<"值为2的结点的下一个结点值是："<<p->next->data<<endl;
    cout<<"值为2的结点的上一个结点值是："<<p->prior->data<<endl;
    //按位查找
    p = GetElem(L,3);
    cout<<"第三个结点值是："<<p->data<<endl;
    
    //插入操作
    Insert(L,p,7);
    cout<<"在第三个结点后面插入值为7的结点后L： ";
    PrintList(L);
    
    //删除操作
    Delete(L, 5);
    cout<<"删除第五个结点后L： ";
    PrintList(L);
    
    //求表长
    cout<<"表长为："<<Length(L)<<endl;;
    
    //判空
    Empty(L);
    return 0;
}

 运行结果：

在这里插入图片描述

总结

 双链表与单链表在某些操作上几乎是相同的，比如按位查找，按值查找，求表长，打印链表等等，但由于双链表有指向前驱结点的指针，故双链表在初始化，建立双链表，插入操作，删除操作等函数内需要对前驱结点的指针进行修改。本文中插入和删除操作都是对结点*q的后面进行插入和删除，由于双链表有指向前驱结点的指针，故这些操作也可以转换为在某个结点前的插入删除操作等等。

薛定谔的猫ovo
关注
  • 64
    点赞
  • 踩
  • 422
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
双链表的初始化（头插和尾插）,插入，删除操作
Boyt1317的博客
10-16 2032
双链表的创建（全），插入和删除操作
双链表的定义、初始化、插入、删除和销毁
youngurt的博客
05-15 586
1.双链表定义 //双链表定义 typedef struct DNode{ ElemType data; //数据域 struct DNode *prior, *next; //前驱和后继指针 }DNode, *DLinkList; 2.初始化双链表 //初始化双链表 bool InitDLinkList(DLinkList &L){ L = (DNode *)malloc(sizeof(DNode)); //创建头结点 if(L==NULL) return false; //内存
创建双向循环链表（C语言）——尾插法
2201_75378704的博客
08-23 425
【代码】创建双向循环链表——尾插法（C语言）
双链表
weixin_30654583的博客
09-14 54
今天，我们一起用C++写一个双链表，具体代码如下：DoubleList.h具体内容如下：#include "NodeList.h" template<typename Type> class DoublyList{ public: DoublyList() :head(new ListNode<Type>()){ //the head node poi...
数据结构第五讲：双链表
最新发布
2301_79761834的博客
07-27 533
数据结构第五讲：双链表
双链表的基本操作
今晚打老虎
10-11 437
http://blog.csdn.net/gaoxiang_/article/details/8279536  双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。       为了练习，我这次设置了哨兵结点，哨兵结点，我个人理解就是我们一般意义上的头结点（是链
双向链表的插入及删除图解
热门推荐
c++菜鸟一只。
05-06 3万+
双向链表的插入第一步：首先找到插入位置，节点 s 将插入到节点 p 之前 第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; 第三步：将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s; 第四步：将节点 s 的后继指向节点 p 即 s->next = p; 第五步：将节点 p 的前驱指向节点 s 即 p->prior =
双链表的基本操作（创建，插入，删除，读取等）
10-29
双链表基本操作的程序，（先在主程序内定义一个数组，再把数组内的元素作为结点一个个插入到链表内，显示链表内所有结点及链表长度，删除某一个结点，再次显示链表内所有结点以及链表长度）。
双向链表的基本操作
Kuches的博客
03-08 440
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、初始化双线性链表二、双向链表的节点插入二、双向链表的节点删除三、双向链表的节点修改四、双向链表的打印总结 前言 对双线性链表进行一些基础操作 一、初始化双线性链表 利用尾插法建立一个双向链表 代码示例 void InitDList(DLinkList*L) { (*L)=(DLNode*)malloc(sizeof(DLNode)); (*L)->pre=NULL; (*L)->next=NULL;
双链表基本操作
致宁的大博客！
10-18 161
#define _CRT_SECURE_NO_WARNINGS #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Head *PHead; typedef struct Node *PNode; struct Head { //头结点 int length; PNode next; }; struct N...
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1012
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
数据结构第四篇——（一般）线性表（基于C语言）
qq_34028001的博客
08-02 376
前言 以下描述内容以C语言为主，Java只是作为实现的补充。 一、线性表的定义及性质 线性表是由n(n>=O)个数据类型相同的元素构成的有限序列。 线性表中元素的个数n(n>=O)定义为表长，n=O时称为空表。 线性表按照存储结构的不同，又划分为顺序表和链式表。 1.1 顺序表的定义及其特点 顺序表（Sequential List）：用一组地址连续的存储单元依次存储线性表的数据元素。 其特点是： 逻辑上相邻的数据元素，其物理次序也是相邻的； 随机访问，可以在O(1)时...
Python面试——数据结构（二）
举世无双的博客
03-08 685
数据结构 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。 逻辑结构：数据之间的相互关系。 集合 结构中的数据元素除了同属于一种类型外，别无其它关系。 线性结构 数据元素之间一对一的关系 树形结构 数据元素之间一对多的关系 图状结构或网状结构 结构中的数据元素之间存在多对多的...
学习记录 mooc浙大数据结构第二讲 线性结构（附向前星的详细讲解，持续更新中）
Love_Jacques的博客
08-23 337
写在读前：作者于2020年暑期学习本课程，于2020年暑期末写下本博客，博客内容包括课程框架梳理，要点总结，PTA课后题解，多有理解不当或者概念错误请多多指出并加以包涵~ 线性表 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 ——引自百度百科“线性表”词条 顺序存储——数组 最简单的数据结构；定义一个头指针，所有元素根据头指针位置依次按顺序储存。 定义：Element
《数据结构与算法》的概括
weixin_41719737的博客
12-13 309
《数据结构与算法》须掌握的知识点： 第一章 绪论 基本概念和术语： 1.数据、数据元素、数据项和数据类型 数据：所有能被输入到计算机中，且能被计算机处理的符号的集合。是计算机操作的对象的总称。 数据元素：数据（集合）中的一个“个体”，数据及结构中讨论的基本单位 数据项：数据的不可分割的最小单位。一个数据元素可由若干个数据项组成。 数据类型：在一种程序设计语言中，变量所具有的数据种类。整型、...
编写程序，实现单链表的基本操作：初始化、建表（头插法或尾插法）、查找、插入、删除、求表长。C语言
09-26
可以通过以下代码实现单链表的基本操作： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } Node; // 初始化链表 void initLinkedList(Node** head) { *head = NULL; } // 头插法建表 void createLinkedListHead(Node** head) { int data; printf("输入节点数据，输入-1结束："); while (1) { scanf("%d", &data); if (data == -1) { break; } Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = *head; *head = newNode; } } // 尾插法建表 void createLinkedListTail(Node** head) { int data; printf("输入节点数据，输入-1结束："); Node* tail = NULL; while (1) { scanf("%d", &data); if (data == -1) { break; } Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (*head == NULL) { *head = newNode; tail = newNode; } else { tail->next = newNode; tail = newNode; } } } // 查找节点 Node* findNode(Node* head, int target) { Node* p = head; while (p != NULL) { if (p->data == target) { return p; } p = p->next; } return NULL; } // 插入节点 void insertNode(Node** head, int pos, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (pos == 0) { newNode->next = *head; *head = newNode; return; } Node* p = *head; int count = 0; while (p != NULL && count < pos - 1) { p = p->next; count++; } if (p == NULL) { printf("位置无效！\n"); return; } newNode->next = p->next; p->next = newNode; } // 删除节点 void deleteNode(Node** head, int data) { Node* p = *head; Node* prev = NULL; // 删除的是头节点 if (p != NULL && p->data == data) { *head = p->next; free(p); return; } while (p != NULL && p->data != data) { prev = p; p = p->next; } if (p == NULL) { printf("未找到要删除的节点！\n"); return; } prev->next = p->next; free(p); } // 求表长 int getLength(Node* head) { int len = 0; Node* p = head; while (p != NULL) { len++; p = p->next; } return len; } // 打印链表 void printLinkedList(Node* head) { Node* p = head; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } int main() { Node* head; initLinkedList(&head); createLinkedListTail(&head); printLinkedList(head); int target; printf("输入要查找的节点数据："); scanf("%d", &target); Node* result = findNode(head, target); if (result != NULL) { printf("找到了！\n"); } else { printf("未找到！\n"); } int pos, data; printf("输入要插入的位置和数据："); scanf("%d %d", &pos, &data); insertNode(&head, pos, data); printLinkedList(head); printf("输入要删除的节点数据："); scanf("%d", &target); deleteNode(&head, target); printLinkedList(head); int length = getLength(head); printf("链表长度：%d\n", length); return 0; } ```
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值