13.双向链表的算法实现

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

1.定义

typedef struct _LinkNode
{
    int data; //结点的数据域
    struct _LinkNode *next; //下一个节点的指针域
    struct _LinkNode *prev; //上一个结点的指针域
}LinkNode, LinkList; //LinkList 为指向结构体LNode 的指针类型

2.双向链表的初始化

typedef struct _DoubleLinkNode
{
    int data; //结点的数据域 
    struct _DoubleLinkNode *next; //下一个节点的指针域
    struct _DoubleLinkNode *prev; //上一个结点的指针域
}DbLinkNode, DbLinkList; //LinkList 为指向结构体LNode 的指针类型

bool DbInit_List(DbLinkList* &L)//构造一个空的双向链表L
{
    L=new DbLinkNode; //生成新结点作为头结点，用头指针L指向头结点
    if(!L)return false; //生成结点失败
    L->next=NULL; //头结点的next 指针域置空
    L->prev=NULL; //头结点的指针域置空
    L->data = -1;
    return true;
}

3.双向链表增加元素

3.1前插法

//前插法
bool DbListInsert_front(DbLinkList* &L, DbLinkNode *node)
{
    if(!L || !node) return false;
    //1.只有头节点
    if(L->next==NULL)
    {
        node->next=NULL;
        node->prev=L; //新节点prev指针指向头节点
        L->next=node; //头节点next 指针指向新节点
    }
    else
    {
        L->next->prev=node; //第二个节点的prev指向新节点
        node->next = L->next; //新节点next指针指向第二个节点
        node->prev=L; //新节点prev 指针指向头节点
        L->next=node; //头节点next 指针指向新节点，完成插入
    }
    return true;
}

3.2尾插法

//尾插法
bool DbListInsert_back(DbLinkList* &L, DbLinkNode *node)
{
    DbLinkNode *last = NULL;
    if(!L || !node) return false;
    last = L;
    while(last->next) last = last->next;
    node->next = NULL;
    last->next = node;
    node->prev = last;      
    return true;
}

3.3任意位置插入

//指定位置插入
bool DbLink_Insert(DbLinkList* &L, int i, int &e)
{
    if(!L||!L->next) return false;
    if(i<1) return false;
    int j =0;
    DbLinkList *p, *s;
    p = L;
    while(p && j<i)
    {
        //查找位置为i的结点，p 指向该结点
        p = p->next;
        j++;
    }
    if(!p)//超出范围
    {
        cout<<"不存在节点："<<i<<endl;
        return false;
    }
    cout<<"p: "<<p<<endl;
    s=new DbLinkNode;//生成新节点
    s->data = e;
    s->next = p;
    s->prev = p->prev;
    p->prev->next = s;
    p->prev = s;
    return true;
}

3.4双向链表的遍历

//双向链表的遍历输出
void DbLink_Print(DbLinkList* &L )
{
    DbLinkNode *p = NULL;
    if(!L)
    {
        cout<<"链表为空."<<endl;
        return ;
    }
    p = L;
    while(p->next)
    {
        cout<<p->next->data<<"\t";
        p = p->next;
    }//p->next为NULL，所以p指向最后一个结点
    //逆向打印
    cout<<endl<<"逆向打印"<<endl;
    while(p)
    {
        cout<<p->data<<"\t";
        p = p->prev;
    }
    cout<<endl;
}

3.5双向链表获取元素

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

3.6双向链表删除元素

//任意位置删除
bool DbLink_Delete(DbLinkList* &L, int i) //双向链表的删除
{
    DbLinkList *p;
    int index = 0;
    if(!L || !L->next)
    {
        cout<<"双向链表为空!"<<endl;
        return false;
    }
    if(i<1) return false; //不能删除头节点
    p=L;
    while(p && index<i)
    {
        p = p->next;
        index++;
    }
    if(!p)
    { 
        //当节点不存在时，返回失败
        return false;
    }
    p->prev->next=p->next; //改变删除结点前驱结点的next 指针域
    if(p->next)
    {
        p->next->prev = p->prev; //改变删除节点后继节点的prev 指针域
    }
    delete p; //释放被删除结点的空间
    return true;
}

3.6双向链表销毁

void DbLink_Destroy(DbLinkList* &L) //双向链表的销毁
{
    //定义临时节点p 指向头节点
    DbLinkList *p = L;
    cout<<"销毁链表!"<<endl;
    while(p)
    {
        L=L->next;//L 指向下一个节点
        cout<<"删除元素: "<<p->data<<endl;
        delete p; //删除当前节点
        p = L; //p 移向下一个节点
     }
}

完整代码实现：

#include<iostream>
#include<string>
#include<stdlib.h>

using namespace std;

typedef struct _DoubleLinkNode 
{
    int data; //结点的数据域
    struct _DoubleLinkNode *next; //下一个节点的指针域
    struct _DoubleLinkNode *prev; //上一个结点的指针域
}DbLinkNode, DbLinkList; //LinkList 为指向结构体LNode 的指针类型

bool DbList_Init(DbLinkList* &L)//构造一个空的双向链表L
{
    L=new DbLinkNode; //生成新结点作为头结点，用头指针L 指向头结点
    if(!L)return false; //生成结点失败
    L->next=NULL; //头结点的next 指针域置空
    L->prev=NULL; //头结点的prev 指针域置空
    L->data = -1;
    return true; 
}
//前插法
bool DbListInsert_front(DbLinkList* &L, DbLinkNode *node)
{
    if(!L || !node) return false;
    //1.只有头节点
    if(L->next==NULL)
    {
        node->next=NULL;
        node->prev=L; //新节点prev 指针指向头节点
        L->next=node; //头节点next 指针指向新节点
    }
    else
    { 
        L->next->prev=node; //第二个节点的prev 指向新节点    
        node->next = L->next; //新节点next 指针指向第二个节点   
        node->prev=L; //新节点prev 指针指向头节点    
        L->next=node; //头节点next 指针指向新节点，完成插入
    }
    return true;
}

//尾插法
bool DbListInsert_back(DbLinkList* &L, DbLinkNode *node)
{
    DbLinkNode *last = NULL;
    if(!L || !node) return false;
    last = L;
    while(last->next) last = last->next;
    node->next = NULL;
    last->next = node;
    node->prev = last;
    return true;
}
//指定位置插入
bool DbLink_Insert(DbLinkList* &L, int i, int &e)
{
    if(!L||!L->next) return false;
    if(i<1) return false;
    int j =0;
    DbLinkList *p, *s; 
    p = L;
    while(p && j<i)
    {
        //查找位置为i 的结点，p 指向该结点
        p = p->next;
        j++;
    }
    if(!p || j!=i)
    {
        cout<<"不存在节点："<<i<<endl;
        return false;
    }
    cout<<"p: "<<p<<endl;
    s=new DbLinkNode;//生成新节点
    s->data = e;
    s->next = p;
    s->prev = p->prev;
    p->prev->next = s;
    p->prev = s;
    return true;
}
void DbLink_Print(DbLinkList* &L )
{
    DbLinkNode *p = NULL;
    if(!L)
    {
        cout<<"链表为空."<<endl;
        return;
    }
    p = L;
    while(p->next)
    {
        cout<<p->next->data<<"\t";
        p = p->next;
    }
    //逆向打印
    cout<<endl<<"逆向打印"<<endl;
    while(p)
    {
        cout<<p->data<<"\t";
        p = p->prev;
    }
    cout<<endl;
}
bool DbLink_GetElem(DbLinkList* &L, int i, int &e)//双向链表的取值
{
    //在带头结点的双向链表L 中查找第i 个元素
    //用e 记录L 中第i 个数据元素的值
    int index;
    DbLinkList *p;
    if(!L || !L->next) return false;
    p = L->next;
    index = 1;
    while(p && index<i)//顺链表向后扫描，直到p 指向第i个元素或p为空
    {
        p = p->next; //p 指向下一个结点
        index++; //计数器index 相应加1
    }
    if(!p || index>i)
    {
        return false; //i 值不合法,i＞n 或i<=0
    }
    e=p->data;
    return true;
}

bool DbLink_Delete(DbLinkList* &L, int i) //双向链表的删除
{
    DbLinkList *p;
    int index = 0;
    if(!L || !L->next)
    {
        cout<<"双向链表为空!"<<endl;
        return false;
    }
    if(i<1) return false; //不能删除头节点
    p=L;
    while(p && index<i)
    {
        p = p->next;
        index++;
    }
    if(!p) //当节点不存在时，返回失败
    {
        return false;
    }
    p->prev->next=p->next; //改变删除结点前驱结点的next 指针域
    p->next->prev = p->prev; //改变删除节点后继节点的prev 指针域
    delete p; //释放被删除结点的空间
    return true;
}
void DbLink_Destroy(DbLinkList* &L) //双向链表的销毁
{
    //定义临时节点p 指向头节点
    DbLinkList *p = L;
    cout<<"销毁链表!"<<endl;
    while(p)
    {
        L=L->next;//L 指向下一个节点
        cout<<"删除元素: "<<p->data<<endl;
        delete p; //删除当前节点
        p = L; //p 移向下一个节点
    }
}

int main(void)
{
    DbLinkList *L = NULL;
    DbLinkNode *s = NULL;
    //1. 初始化一个空的双向链表
    DbList_Init(L);
    //2. 使用前插法插入数据
    int n;
    cout<<"前插法创建双向链表"<<endl;
    std::cout<<"请输入元素个数n：";
    cin>>n;
    cout<<"\n 请依次输入 n 个元素：" <<endl;
    while(n>0)
    {
        s = new DbLinkNode; //生成新节点s
        cin>>s->data;
        DbListInsert_front(L, s);
        n--;
    }
    //3. 使用尾插法插入数据
    cout<<"尾插法创建双向链表"<<endl;
    std::cout<<"请输入元素个数n：";
    cin>>n;
    cout<<"\n 请依次输入n 个元素：" <<endl;
    while(n>0)
    {
        s = new DbLinkNode; //生成新节点s
        cin>>s->data;
        DbListInsert_back(L, s);       
        n--;
    }
    //4. 双向链表的输出
    DbLink_Print(L);
    //5. 任意位置插入元素
    for(int j=0; j<3; j++)
    {
        int i, x;
        cout << "请输入插入的位置和元素（用空格隔开）:";
        cin >> i;
        cin >> x;
        if(DbLink_Insert(L, i, x))
        {
            cout << "插入成功.\n\n";
        }
        else
        {
            cout << "插入失败!\n\n";
        }
        DbLink_Print(L);
    }
    //6. 双向链表根据位置获取元素
    int element = 0;
    if(DbLink_GetElem(L, 2, element))
    {
        cout<<"获取第二个元素成功, 值："<<element<<endl;    
    }
    else 
    {
        cout<<"获取第二个元素失败!"<<endl;
    }
    //7. 双向链表删除元素
    if(DbLink_Delete(L, 2))
    {
        cout<<"删除第2 个元素成功!"<<endl;
        DbLink_Print(L);
    }
    else 
    {
        cout<<"删除第2 个元素失败!"<<endl;
    }
    if(DbLink_Delete(L, 1))
    {
        cout<<"删除第1 个元素成功!"<<endl;
        DbLink_Print(L);
    }
    else
    {
        cout<<"删除第1 个元素失败!"<<endl;
    }
    //8. 销毁双向链表
    DbLink_Destroy(L);
    
    system("pause");
    return 0;
}

参考资料来源：

奇牛学院