C++ "链链"不忘@必有回响之双向链表

1. 前言

写过一篇与单链表相关的博文(https://blog.51cto.com/gkcode/5681771),实际应用中,双向循环链表的功能更强大。

单链表中,查询一个已知结点的后驱结点的时间复杂度为O(1)。因结点本身不存储与前驱结点相关的地址信息,查询前驱结点需要从头结点扫描一次,所以时间复杂度是O(n)

双向链表在结点类型中增加了可以存储前驱结点地址的指针位,如下图所示:

如此,无论查询已知结点的后驱结点还是前驱结点的时间复杂度都是O(1),缺点是需要付出空间上的代价。

在权衡算法性能时,会优先考虑时间复杂度的优劣,往往会采用空间换时间的策略。

结点的类型定义:

typedef int dataType;
//结点
struct LinkNode {
//数据成员
dataType data;
//后驱结点的地址
LinkNode *next;
//前驱结点的地址
LinkNode *pre;
//构造函数
LinkNode(dataType data) {
this->data=data;
this->next=NULL;
this->pre=NULL;
}
};

2. 双向链表

双向链表中除了有存储头结点的head指针变量外,一般还会增加一个存储尾结点的tail指针变量。这样,可以实现从头至尾或从尾至头对链表进行遍历。

为了操作的方便,初始化链表时都会提供一个空白的头结点作为标识结点。

双向链表中,如果尾结点的后驱指针位存储头结点地址,头结点的前驱指针位存储尾结点地址,如此形成一个首尾相连的闭环,则称此链表为双向循环链表

双向链表需要提供对结点上的数据进行常规维护的操作,如:

  • 链表初始化。
  • 创建链表。
  • 查找。
  • 后插入、前插入。
  • 删除。
  • ……

算法的整体思路和单链表相似,因结点中多了一个前驱结点信息,为各种操作带来便利的同时,也多了需要关注的细节。

下文将介绍双向链表中的几个重要函数。

2.1 初始化

如果是双向循环链表,初始化时:

  • headtail指向空白头结点。
  • head的前驱结点和tail的后驱结点也指向空白头结点。这个过程也可以放到创建链表时实现。

class LinkList {
private:
//头指针
LinkNode *head;
//尾指针
LinkNode *tail;
//链表的长度
int length;
public:
//构造函数
LinkList() {
this->initLinkList();
}
//初始化链表
void initLinkList() {
//头指针存储空白头结点地址
this->head=new LinkNode(0);
//尾指针和头指针位置相同
this->tail=this->head;
//尾结点的后驱结点是头结点
this->tail->next=this->head;
//头结点的前驱结点是尾结点
this->head->pre=this->tail;
}
//……其它函数

2.2 创建链表

可以使用头部插入或尾部插入算法创建链表,本文仅介绍尾部插入创建算法,头部创建算法可自行了解。如下演示使用尾部创建法构建以数列{7,3}为数据的链表。

  • 创建值为7的新结点n

  • 设置新结点n的前驱结点为原尾结点。
n->pre=tail;

  • 设置新结点n的后驱结点为原尾结点的后驱结点。
n->next=tail->next;

  • 设置原尾结点的后驱结点为新结点n
tail->next=n;

  • 新结点n成为新的尾结点。
tail=n;

  • 设置头结点的前驱结点为新的尾结点。
head->pre=tail;

重复上述流程,最终完成链表的创建过程。

是否可以无视上述创建流程中的顺序?

全局而言,顺序基本是要遵循上述的要求,原则是新结点->尾结点->头结点

  • 新结点:先设置新结点的前驱和后驱结点的地址。新结点的相应存储位都是空白的,先设置前驱还是后驱不影响结果。
  • 尾结点:修改原尾结点的后驱结点地址为新结点,原尾结点的使命完成后,再指定新结点为新的尾结点。
  • 头结点:修改头结点的前驱地址为新尾结点。

编码实现:

//尾部插入方式创建链表
void createFromTail(int n) {
LinkNode *newNode,*p,*tail;
//头结点地址
p=this->head;
//尾结点地址
tail=this->tail;
for(int i=0; i<n; i++) {
//构建一个新结点
newNode=new LinkNode(0);
cout<<"请输入结点数据"<<endl;
cin>>newNode->data;
//原来的尾结点成为新结点的前驱结点
newNode->pre=tail;
//新结点的后驱结点为原来的尾结点的后驱结点
newNode->next=tail->next;
//原尾结点的后驱结点为新结点
tail->next=newNode;
//新结点成为新的尾结点
tail=newNode;
//头结点的前驱为新尾结点
head->pre=tail;
}
this->head=p;
this->tail=tail;
}

测试尾部创建:

int main(int argc, char** argv) {
LinkList list {};
list.createFromTail(2);
//没删除之前
cout<<"显示创建结果:"<<endl;
LinkNode *head= list.getHead();
cout<<"从头结点向尾结点方向搜索:"<<endl;
cout<<head->next->data<<endl;
cout<<head->next->next->data<<endl;
LinkNode *tail=list.getTail();
cout<<"从尾结点向头结点方向搜索 :"<<endl;
cout<<tail->data<<endl;
cout<<tail->pre->data<<endl;
head=tail->next;
cout<<"从尾结点的后驱信息位得到头结点信息 :"<<endl;
cout<<head->next->data<<endl;
cout<<head->next->next->data<<endl;
return 0;
}

执行结果:

2.3 查找

双向循环链表的头尾是相连的,其查询方案可以有多种变化:

  • 按位置查找: 按位置查找建议从头结点开始。
  • 按值查找: 按值查找可以从头结点或从尾结点开始。
  • 查询所有: 查询所有可以从头结点也可以从尾结点开始。

2.3.1 按位置查找

设空白头结点编号为0,从头结点向尾结点扫描过程中,给扫描到的结点依次编号,当查询到和指定参数相同的编号时停止。

//按位置查询结点(从头部扫描到尾部)
LinkNode * findNodeByIndex(int index) {
int j=0;
LinkNode *p=this->head;
if(index==j)
//如果 index 值为 0 ,返回空白头结点
return p;
//第一个数据结点
p=p->next;
//设置第一个数据结点的编号为 1 ,当然这不是绝对,可以根据自己的需要设置编号
j=1;
while(p!=this->head && j<index) {
p=p->next;
j++;
}
if(j==index)return p;
else return NULL;
}

2.3.2 按值查找

按值查找可以有 2 种方案:

  • 头结点向尾结点方向查找。
//按值查询结点
LinkNode * findNodeByVal(dataType val) {
//从第一个数据结点开始查找
LinkNode *p=this->head->next;
//当 p 再次指向头结点结束查找,这也空白结点存在的意义
while(p!=this->head && p->data!=val ) {
p=p->next;
}
if(p!=this->head) {
return p;
} else {
return NULL;
}
}
  • 尾结点向头结点方向查找。
LinkNode * findNodeByValFromTail(dataType val) {
//从尾结点开始查找
LinkNode *p=this->tail;
while(p!=this->head && p->data!=val ) {
//向头结点方向
p=p->pre;
}
if(p!=this->head) {
return p;
} else {
return NULL;
}
}

2.3.3 查询所有

  • 从头结点向尾结点方向查询所有结点。
void showSelf() {
if(this->head==NULL)return;
//得到第一个数据结点
LinkNode *p=this->head->next;
while(p!=this->head) {
cout<<p->data<<"\t";
p=p->next;
}
}
  • 从尾结点向头结点方向查询所有结点。
void showSelf_() {
if(this->tail==NULL)return;
LinkNode *p=this->tail;
while(p!=this->head) {
cout<<p->data<<"\t";
p=p->pre;
}
}

2.4 插入

插入有前插入和后插入 2 种方案,于双向链表而言,其时间复杂度都为O(1)

2.4.1 后插入

把新结点插入到已知结点的后面,称为后插入,其插入流程如下所示:

  • 找到已知结点p,创建新结点n

  • 设置n结点的前驱结点为已知结点p,设置其后驱结点为已知结点p的后驱结点。
n->pre=p;
n->next=p->next;

  • 设置p结点的后驱结点为n结点。
p->next=n;

  • 设置结点n为其后驱结点的前驱结点。
n->next->pre=n;

编码实现:

	//后插入
int instertAfter(dataType val,dataType data) {
//按值查找到结点
LinkNode *p=this->findNodeByVal(val);
if (p==NULL) {
//结点不存在,返回 false
return false;
}
//创建新结点
LinkNode *n=new LinkNode(0);
n->data=data;
//设置 p 结点为新结点的前驱结点
n->pre=p;
//新结点的后驱结点为已知结点 p 的后驱结点
n->next=p->next;
//已知结点的后驱结点为新结点
p->next=n;
//已知结点的原后驱结点的前驱结点为新结点
n->next->pre=n;
return true;
}

测试后插入:

int main(int argc, char** argv) {
LinkList list {};
//创建 7,3 两个结点
list.createFromTail(2);
//在结点 7 后面插入值为 9 的结点
list.instertAfter(7,9);
list.showSelf();
return 0;
}

执行结果:

2.4.2 前插入

把新结点插入到已知结点的前面,称为前插入,因结点有前驱结点的地址信息,双向链表的前或后插入都较方便。

  • 找到已知结点p,创建新结点n

  • 设置结点n的前驱结点为p的前驱结点,设置其后驱结点为p结点。
n->pre=p->pre;
n-next=p;

  • 设置p结点的前驱结点的后驱结点为n
p->pre->next=n;

n->pre->next=n;

  • 设置p结点的前驱结点为n结点。
p->pre=n;

编码实现:

//前插入
int insertBefore(dataType val,dataType data) {
//按值查找到结点
LinkNode *p=this->findNodeByVal(val);
if (p==NULL)
return false;
//查找前驱结点
LinkNode *p1=this->head;
while(p1->next!=p) {
p1=p1->next;
}
//构建新结点
LinkNode *n=new LinkNode(0);
n->data=data;
//新结点的后驱为 p 结点
n->next=p;
//新结点的前驱为 p 的前驱
n->pre=p->pre;
//p 的前驱结点的后驱结点为 n
p->pre->next=n;
//p 的前驱结点为 n
p->pre=n;
return true;
}

测试前插入:

int main(int argc, char** argv) {
LinkList list {};
//创建 7,3 两个结点
list.createFromTail(2);
//在值为 7 的结点前面插入值为 9 的结点
list.insertBefore(7,9);
list.showSelf();
return 0;
}

执行结果:

2.5 删除

2.5.1 删除结点

删除已知结点的基本操作流程:

  • 查找到要删除的结点p

  • 找到结点p的前驱结点,设置其后驱结点为p的后驱结点。
p->pre->next=p->next;

  • 找到p结点的后驱结点,设置其前驱结点为p结点的前驱结点。删除p结点。
p->next->pre=p->pre;
delete p;

编码实现:

int delNode(dataType data) {
//按值查找到要删除的结点
LinkNode *p= this->findNodeByVal(data);
if (p==NULL)return false;
//设置 p 的前驱结点的后驱结点
p->pre->next=p->next;
p->next->pre=p->pre;
delete p;
return true;
}

测试删除操作:

LinkList list {};
//创建 {7,3,9} 3个结点
list.createFromTail(3);
//LinkNode *res= list.findNodeByValFromTail(4);
list.delNode(3);
list.showSelf();

执行结果:

2.5.2 删除所有结点

编码实现:

void delAll() {
LinkNode *p=this->head->next;
//临时结点
LinkNode *p1;
while(p!=this->head) {
//保留删除结点的后驱结点
p1=p->next;
delete p;
p=p1;
}
this->head=NULL;
}

3. 算法案例

界定数列的要求:对于一个无序数列,首先在数列中找出一个基数,然后以基数为分界点,把小于基数的数字放在基数前面,反之放在后面。

3.1 演示流程

使用双向循环链表实现界定数列的流程。

  • 已知的无序数列:

  • 选择基数。这里选择第一个数字 7 作为基数。保存在临时变量 tmp中。声明 2 个变量 leftright,分别指向第一个数据和最后一个数据。

  • right位置开始扫描整个数列,如果 right位置的数字大于 tmp中的值,则继续向左移动right指针直到遇到比 tmp中值小的数字,然后保存到 left位置。

  • left指针的工作要求:当所处位置的数字比tmp值小时,则向右边移动直到遇到比tmp值大的数字,然后保存至right

  • 重复上述过程,直到 leftright指针重合。

  • 最后把tmp中的值复制到leftright指针最后所指向的位置。最终实现以数字7界定整个数列。

3.2 算法实现

使用双向链表实现上述需求:

  • 初始化链表,并以尾部插入方式(保证数列的逻辑顺序和物理顺序一致)创建数列{7,3,1,9,12,5,8}
int main(int argc, char** argv) {
LinkList list {};
list.createFromTail(7);
//没删除之前
cout<<"显示创建结果:"<<endl;
list.showSelf();
return 0;
}

执行后结果:

  • 编写界定算法。
void  baseNumBound() {
//第一个数据结点的数据作为界定数字
int tmp=this->head->next->data;
//左指针,指向第一个数据结点
LinkNode *left=this->head->next;
//右指针,指向尾结点
LinkNode *right=this->tail; while(left!=right) {
while(left!=right && right->data>tmp) {
//右指针向左移动
right=right->pre;
}
left->data=right->data;
while(left!=right && left->data<tmp) {
//左指针向右移动
left=left->next;
}
right->data=left->data;
}
left->data=tmp;
}

测试代码:

int main(int argc, char** argv) {
LinkList list {};
list.createFromTail(7);
//没删除之前
cout<<"显示链表的创建结果:"<<endl;
list.showSelf();
list.baseNumBound();
cout<<"\n显示界定后的数列:"<<endl;
list.showSelf();
return 0;
}

执行结果:

使用双向循环链表,实现界定数列简单、明了。

4. 总结

双向链表的结点多了一个前驱指针位,对其内部数据的维护提供了大大的便利。对于程序而言,已知数据越多,算法也将会有更大灵活伸缩空间。

C++ "链链"不忘@必有回响之双向链表的更多相关文章

  1. BZOJ2157: 旅游 树链剖分 线段树

    http://www.lydsy.com/JudgeOnline/problem.php?id=2157   在对树中数据进行改动的时候需要很多pushdown(具体操作见代码),不然会wa,大概原因 ...

  2. NGK公链如何构建区块链数字经济商业帝国?

    2020年对于区块链市场来说,重大的利好消息莫过于NGK公链的上线了.NGK公链其广泛的市场前景.顶尖的技术,一直备受众多大型机构以及投资者所看好.同时,NGK公链也不负众望,在上线以后,就开始落地到 ...

  3. atitit.设计模式(1)--—职责链模式(chain of responsibility)最佳实践O7 日期转换

    atitit.设计模式(1)---职责链模式(chain of responsibility)最佳实践O7 日期转换 1. 需求:::日期转换 1 2. 可以选择的模式: 表格模式,责任链模式 1 3 ...

  4. Js作用域链及变量作用域

    要理解变量的作用域范围就得先理解作用域链 用var关键字声明一个变量时,就是为该变量所在的对象添加了一个属性. 作用域链:由于js的变量都是对象的属性,而该对象可能又是其它对象的属性,而所有的对象都是 ...

  5. atitit.(设计模式1)--—职责链(chain of responsibility)最佳实践O7 转换日期

    atitit.设计模式(1)---职责链模式(chain of responsibility)最佳实践O7 日期转换 1. 需求:::日期转换 1 2. 能够选择的模式: 表格模式,责任链模式 1 3 ...

  6. js学习--变量作用域和作用域链

    作为一名菜鸟的我,每天学点的感觉还是不错的.今天学习闭包的过程中看到作用域与作用域链这两个概念,我觉得作为一名有追求的小白,有必要详细了解下. 变量的作用域 就js变量而言,有全局变量和局部变量.这里 ...

  7. [kuangbin]树链剖分 D - 染色

    https://vjudge.net/contest/251031#problem/Dhttps://blog.csdn.net/kirito_acmer/article/details/512019 ...

  8. KVM虚拟机快照链创建,合并,删除及回滚研究

    1 QEMU,KVM,libvirt关系 QEMU QEMU提供了一个开源的服务器全虚拟化解决方案,它可以使你在特定平台的物理机上模拟出其它平台的处理器,比如在X86 CPU上虚拟出Power的CPU ...

  9. 树链剖分 树剖求lca 学习笔记

    树链剖分 顾名思义,就是把一课时分成若干条链,使得它可以用数据结构(例如线段树)来维护 一些定义: 重儿子:子树最大的儿子 轻儿子:除了重儿子以外的儿子 重边:父节点与重儿子组成的边 轻边:除重边以外 ...

  10. 长链剖分优化树形DP总结

    长链剖分 规定若\(x\)为叶结点,则\(len[x]=1\). 否则定义\(preferredchild[x]\)(以下简称\(pc[x]\),称\(pc[x]\)为\(x\)的长儿子)为\(x\) ...

随机推荐

  1. 给 Android 研发的一些的建议

    作为应用程序开发人员,我们需要注意在开发应用程序时的一些问题. 这些问题的安全级别是取决于应用程序的类型和使用域. 在这里列举了一些我们在开发中需要注意的一些问题: 开发日志输出相关: 1. 不要在 ...

  2. Happy New Year

    今年的元旦能明显感觉到节日的狂欢.一方面,论文的事情,压抑了好久,另一方面,把自己融入节日之中.所以才有了节日的深度参与. 早上还是按时的起床,看了朋友圈,内心却能专注于平静.因为见到了优秀的人,才发 ...

  3. VMware 12 的vmware tools安装和如何使用(系统是CENTOS6.5)

    1.用了一下虚拟机vmware12,但是总是没法使用它的vmware Tool ,网上一直说在哪个哪个文件夹,其实并没有 2.于是我用命令行找到了在系统中的VMware Tools 3.首先,保证li ...

  4. oracle 行列转换的运用

    问题: 员工表: A(E_ID,NAME,) 部门表:  B(D_ID,D_NAME) 员工与部门关系:C(ID,E_ID,D_ID) SELECT  A.E_ID,A.NAME ,B.D_NAME ...

  5. SQL SERVER 实现分组合并实现列数据拼接

    需求场景: SQL SERVER 中组织的数据结构是一个层级关系,现在需要抓出每个组织节点以上的全部组织信息,数据示例如下: ADOrg_ID--------------ParentID------- ...

  6. 关于使用由CA机构(EJBCA)颁发的证书实现SLLSocket双向认证服务端报null cert chain的解决方案

    在 SSLSocket实现服务端和客户端双向认证的例子 文章中最后提到使用keytool.exe的自签证书实现双向认证可以,但是使用ejbca生成证书实现SLL Socket的双向认证是服务端老是报错 ...

  7. main thread starting…

    例的结果,下面的: main thread starting- Thrad 2 staring- Thrad 2 end- Thrad 4 staring- Thrad 4 end- Thrad 1 ...

  8. js控制div显示与隐藏

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  9. c#params应用

    params 是C#开发语言中关键字, params主要的用处是在给函数传参数的时候用,就是当函数的参数不固定的时候. 在方法声明中的 params 关键字之后不允许任何其他参数,并且在方法声明中只允 ...

  10. 破解百度云盘MAC下载限速问题

    由于电脑更新问题,所以把电脑上的所有东西清除了.突然发现自己以前的东西还都在百度云盘上,但由于MAC 下载百度云盘上的东西只有几K或者几十K,这个网速对于小文件还能忍受,但如果是大文件就无法容忍了. ...