数据结构 第4-2讲 双向链表

数据结构第4-2讲双向链表
链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不一定相邻，那么怎么表示逻辑上的相邻关系呢？

可以给每个元素附加一个指针域，指向下一个元素的存储位置。这种链表称为单向链表，简称单链表，如图1所示：



单链表中每个结点除了存储自身数据之后，还存储了下一个结点的地址，因此可以轻松访问下一个结点，以及后面的后继结点，但是如果想访问前面的结点就不行了，再也回不去了。例如删除结点p时，要先找到它的前一个结点q，然后才能删掉p结点，单向链表只能往后走，不能向前走。如果需要向前走，怎么办呢？

可以给每个元素附加两个指针域，一个存储前一个元素的地址，一个存储下一个元素的地址。这种链表称为双向链表，如图2所示：



从图2中可以看出，双向链表每个结点包含三个域：数据域和两个指针域，指针域分别存储前后两个元素结点的地址，即前驱和后继。因此指针指向的类型也是结点类型。

结点结构体的定义：



下面以带头结点的双链表为例，讲解双向链表的初始化、创建、取值、查找、插入、删除操作。

1.
双向链表初始化

双向链表初始化是指构建一个空表：



bool InitList_L(DuLinkList &L)//构造一个空的双向链表L

{

    L=new DuLNode; //生成新结点作为头结点，用头指针L指向头结点

    if(!L)

        return false; //生成结点失败

    L->prior=L->next=NULL; //头结点的两个指针域置空

    return true;

}

2.
双向链表的创建

创建双向链表也可以用前插法和尾插法，前插法创建的链表和输入顺序正好相反，因此称为逆序建表，尾插法创建的链表和输入顺序一致，因此称为正序建表。

前插法建表如图：

(1)
初始状态



(2)
输入数据元素1，创建新结点，把元素1放入新结点数据域：



s=new DuLNode; //生成新结点s
cin>>s->data; //输入元素值赋给新结点的数据域
(3)
前插操作，插入到头结点的后面：



(4)
输入数据元素2，创建新结点，把元素2放入新结点数据域：



(5)
前插操作，插入到头结点的后面：



解释：



注意：赋值语句的右侧是一个地址，左侧是一个结点的指针域。

为什么要先修改后面那个指针呢？

因为一旦修改了L结点的next指针域，那么原来L的后继结点就找不到了，要最后修改L->next指针。

注意：修改指针顺序的原则：先修改没有指针标记的那一端。



如果要插入结点的两端都有标记，例如再定义一个指针q指向第1个结点，那么先修改哪个指针都无所谓了。

拉直链表之后：



(6)
继续依次输入数据元素3，4，5，前插法创建链表的结果：


 

 void CreateDuList_H(DuLinkList &L)//前插法创建双向链表

{

    //输入n个元素的值，建立到头结点的单链表L

    int n;

    DuLinkList s; //定义一个指针变量

    L=new DuLNode;

    L->prior=L->next=NULL; //先建立一个带头结点的空链表

    cout <<"请输入元素个数n："
<<endl;

    cin>>n;

    cout <<"请依次输入n个元素："
<<endl;

    cout <<"前插法创建单链表..." <<endl;

    while(n--)

   {

        s=new DuLNode; //生成新结点s

        cin>>s->data; //输入元素值赋给新结点的数据域

        if(L->next)

       {

           L->next->prior=s;

        }

        s->next=L->next;

        s->prior=L;

        L->next=s; //将新结点s插入到头结点之后

    }

}

尾插法建表同单链表的尾插法建表，需要有一个尾指针，不再赘述。

3.
双向链表取值、查找如同单向链表，不再赘述。

4.
双向链表插入

单链表只有一个指针域，是向后操作的，不可以向前处理，因此单链表如果要在第i个结点之前插入一个元素，则必须先找到第i-1个结点。第i个结点之前插入一个元素相当于把新结点放在第i-1个结点之后。而双向链表不需要，因为有两个指针，可以向前后操作，直接找到第i个结点，就可以把新结点插入到第i个结点之前。



解释：



因为p的前驱结点无标记，一旦修改了p结点的prior指针，p的前驱结点就找不到了，因此，最后修改这个指针。

bool ListInsert_L(DuLinkList &L, int i, int &e)//双向链表的插入

{

    //在带头结点的单链表L中第i个位置之前插入值为e的新结点

    int j;

    DuLinkList p, s;

    p=L;

    j=0;

    while (p&&j<i) //查找第i个结点，p指向该结点

   {

        p=p->next;

        j++;

    }

    if (!p || j>i)//i＞n+1或者i＜1

        return false;

    s=new DuLNode; //生成新结点

    s->data=e; //将新结点的数据域置为e

    p->prior->next=s;

    s->prior=p->prior;

    s->next=p;

    p->prior=s;

    return true;

}

6.
双向链表删除

删除一个结点，实际上是把这个结点跳过去。要想跳过第i个结点，可以先找到第i个结点。然后修改指针，如图：



p->prior->next=p->next；含义是将p的后继结点的地址赋值给p的前驱结点的next指针域。即p的前驱结点的next指针指向p的后继结点。在这些有关指针的赋值语句中，很多同学不理解，容易混淆，在此说明一下，等号的右侧是结点的地址，等号的左侧是结点的指针域。

p->next->prior =p->prior；含义是将p的前驱结点的地址赋值给p的后继结点的prior指针域。即p的后继结点的prior指针指向p的前驱结点。

这样，就把p结点跳过去了。然后用delete
p释放被删除结点的空间。删除结点修改指针没有顺序，先修改那个都可以。

bool ListDelete_L(DuLinkList &L, int i) //双向链表的删除

{

    //在带头结点的双向链表L中，删除第i个位置

    DuLinkList p;

    int j;

    p=L;

    j=0;

    while((p->next)&&(j<i)) //查找第i个结点，p指向该结点

    {

        p=p->next;

        j++;

    }

    if (!(p->next)||(j>i))//当i>n或i<1时，删除位置不合理

        return false;

    p->prior->next=p->next;

    p->next->prior=p->prior;

    delete p; //释放被删除结点的空间

    return true;

}

双向链表基本操作完整代码：

#include<iostream>
#include<string>
using namespace std;

typedef struct DuLNode {
int data; //结点的数据域
struct DuLNode *prior,*next; //结点的指针域
}DuLNode, *DuLinkList; //LinkList为指向结构体LNode的指针类型

bool InitDuList_L(DuLinkList &L)//构造一个空的双向链表L
{
L=new DuLNode;     //生成新结点作为头结点，用头指针L指向头结点
if(!L)
return false;     //生成结点失败
L->prior=L->next=NULL;   //头结点的两个指针域置空
return true;
}

void CreateDuList_H(DuLinkList &L)//前插法创建双向链表
{
//输入n个元素的值，建立到头结点的单链表L
int n;
DuLinkList s; //定义一个指针变量
L=new DuLNode;
L->prior=L->next=NULL; //先建立一个带头结点的空链表
cout <<"请输入元素个数n：" <<endl;
cin>>n;
cout <<"请依次输入n个元素：" <<endl;
cout <<"前插法创建单链表..." <<endl;
while(n--)
{
s=new DuLNode; //生成新结点s
cin>>s->data; //输入元素值赋给新结点的数据域
if(L->next)
{
L->next->prior=s;
}
s->next=L->next;
s->prior=L;
L->next=s; //将新结点s插入到头结点之后
}
}

bool GetElem_L(DuLinkList L, int i, int &e)//双向链表的取值
{
//在带头结点的双向链表L中查找第i个元素
//用e记录L中第i个数据元素的值
int j;
DuLinkList p;
p=L->next;//p指向第一个结点，
j=1; //j为计数器
while (j<i && p) //顺链域向后扫描，直到p指向第i个元素或p为空
{
p=p->next; //p指向下一个结点
j++; //计数器j相应加1
}
if (!p || j>i)
return false; //i值不合法i＞n或i<=0
e=p->data; //取第i个结点的数据域
return true;
}

bool LocateElem_L(DuLinkList L, int e) //按值查找
{
//在带头结点的双向链表L中查找值为e的元素
DuLinkList p;
p=L->next;
while (p && p->data!=e)//顺链域向后扫描，直到p为空或p所指结点的数据域等于e
p=p->next; //p指向下一个结点
if(!p)
return false; //查找失败p为NULL
return true;
}

bool ListInsert_L(DuLinkList &L, int i, int &e)//双向链表的插入
{
//在带头结点的单链表L中第i个位置之前插入值为e的新结点
int j;
DuLinkList p, s;
p=L;
j=0;
while (p&&j<i) //查找第i个结点，p指向该结点
{
p=p->next;
j++;
}
if (!p || j>i)//i＞n+1或者i＜1
return false;
s=new DuLNode;     //生成新结点
s->data=e;       //将新结点的数据域置为e
p->prior->next=s;
s->prior=p->prior;
s->next=p;
p->prior=s;
return true;
}

bool ListDelete_L(DuLinkList &L, int i) //双向链表的删除
{
//在带头结点的双向链表L中，删除第i个位置
DuLinkList p;
int j;
p=L;
j=0;
while((p->next)&&(j<i)) //查找第i个结点，p指向该结点
{
p=p->next;
j++;
}
if (!(p->next)||(j>i))//当i>n或i<1时，删除位置不合理
return false;
p->prior->next=p->next;
p->next->prior=p->prior;
delete p;        //释放被删除结点的空间
return true;
}

void Listprint_L(DuLinkList L) //双向链表的输出
{
DuLinkList p;
p=L->next;
while(p)
{
cout <<p->data <<"\t";
p=p->next;
}
cout<<endl;
}

int main()
{
int i,x,e,choose;
DuLinkList L;
choose=-1;
while (choose!=0)
{
cout << "1. 初始化\n";
cout << "2. 创建双向链表（前插法）\n";
cout << "3. 取值\n";
cout << "4. 查找\n";
cout << "5. 插入\n";
cout << "6. 删除\n";
cout << "7. 输出\n";
cout << "0. 退出\n";
cout<<"请输入数字选择:";
cin>>choose;
switch (choose)
{
case 1: //初始化一个空的双向链表
if (InitDuList_L(L))
cout << "初始化一个空的双向链表!\n";
break;
case 2: //创建双向链表（前插法）
CreateDuList_H(L);
cout << "前插法创建双向链表输出结果:\n";
Listprint_L(L);
break;
case 3: //双向链表的按序号取值
cout << "请输入一个位置i用来取值:";
cin >> i;
if (GetElem_L(L,i,e))
{
cout << "查找成功\n";
cout << "第" << i << "个元素是："<<e<< endl;
}
else
cout << "查找失败\n\n";
break;
case 4: //双向链表的按值查找
cout<<"请输入所要查找元素x:";
cin>>x;
if (LocateElem_L(L,x))
cout << "查找成功\n";
else
cout << "查找失败! " <<endl;
break;
case 5: //双向链表的插入
cout << "请输入插入的位置和元素（用空格隔开）:";
cin >> i;
cin >> x;
if (ListInsert_L(L, i, x))
cout << "插入成功.\n\n";
else
cout << "插入失败!\n\n";
break;
case 6: //双向链表的删除
cout<<"请输入所要删除的元素位置i:";
cin>>i;
if (ListDelete_L(L, i))
cout<<"删除成功!\n";
else
cout<<"删除失败!\n";
break;
case 7: //双向链表的输出
cout << "当前双向链表的数据元素分别为:\n";
Listprint_L(L);
cout << endl;
break;
}
}
return 0;
}