数据结构与算法——线性表链式存储（双向循环链表）

今天总结线性表中的双向循环链表。

什么是双向循环链表？

  看名字估计也就知道了，首相他是一个循环链表，也就是最后一个结点的指针域不为空，而是指向头结点，其次与单向循环链表相比，它是双向的。所谓双向，就是给每个结点再增加一个指针域，这个指针域指向前一个结点。

 即是下面这样(来自百度图片):

为什么要用双向循环链表？

 无论单链表还是单向循环链表，都只有一个指针域，它们都是直接指向后继结点的，如果要查找当前结点的后继结点，会很方便。但是如果给定一个结点，要得到它的前继结点，就会很麻烦，必须从第一个元素开始遍历，然后判断当某个结点的指针域指向的是当前结点时，就判断该结点为当前结点的前继结点，时间复杂度为O(n)。而如果给每个结点增加一个指针域，指向其前继结点，那么给定一个结点时，直接就可以得到它的前继结点。

如何实现双向循环链表?

<span style="font-family:Courier New;font-size:14px;">#include <iostream>

using namespace std;
template <class T>
struct Node {
    T data;             //数据域
    struct Node<T> *pre; //指向前一个结点
    struct Node<T> *next; //指向后一个结点
};
template <class T>
//双向循环链表 模板类
class DoubleLinkList {
private:
    Node<T> *front; //头指针
public:
    //空的循环链表
    DoubleLinkList() {
        front = new Node<T>; //头结点
        front->next = front;
        front->pre = front;
    }
    ~DoubleLinkList(); //析构函数 释放节点空间
    DoubleLinkList(T a[],int n); //用数组a初始化链表
    void Insert(int i,T x); //插入元毒到指定位置
    T Delete(int i); //删除指定位置的元素
    Node<T> *GetNode(int i);   //返回指定位置的结点
    int GetLength();  //获取链表的长度
    void PrintLinkList(); //遍历链表
};
template <class T>
//尾插法
DoubleLinkList<T>::DoubleLinkList(T a[],int n) {
    front = new Node<T>;
    front->next = front->pre = front; //初始化空表
    for(int i=0;i<n;i++) {
        Node<T> *s = new Node<T>;
        s->next = front->next;  //让当前结点指向头结点
        s->data = a[i];
        s->pre = front;        //当前结点pre指针指向前一个结点
        front->next = s;      //前一个结点指向当前结点
        front->pre = s;
        front = front->next;   //指针后移
    }
}

template <class T>
DoubleLinkList<T>::~DoubleLinkList() {
    Node<T> *p = front->next; //获取头结点
    while(p!=front->next) {
        Node<T> *q = p;   //保存待删结点地址
        p=p->next;
        delete q;
    }
}

template <class T>
int DoubleLinkList<T>::GetLength() {
    Node<T> *p = front->next;
    int count = 1;
    while(p!=front->pre) {
        count++;
        p = p->next;
    }
    return count;

}


template <class T>
void DoubleLinkList<T>::PrintLinkList() {
    Node<T> *p = front->next->next;  //得到第一个结点
    for(int i=0;i<GetLength();i++) {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

template <class T>
Node<T> * DoubleLinkList<T>::GetNode(int i) {
    Node<T> * p = front->next;
    for(int j=0;j<i;j++) {
        p = p->next;
    }
    return p;
}

template <class T>
T DoubleLinkList<T>::Delete(int i) {
    Node<T> *p = front;
    if(i!=1)
       p = GetNode(i-1); //获取待删结点的前一个结点
    if(p) {
        Node<T> *q = p->next;  //保存待删结点
        T x = q->data;         //待删元素
        p->next->next->pre = p; //使待删结点的后继结点的pre指针域指向前一个结点
        p->next = p->next->next;  //前一个结点next指针域指向待删结点后面的那个元素
        delete q;
        return x;
    }
    return 0;

}

/**
    插入操作实现
    思路：
    1.获取待插位置的前一个结点
    2.新建一个结点，将待插结点元素保存到其数据域中
    3.将待插结点指向插入位置后面的那个结点，其pre指向前面的那个结点
    4.将后面结点的pre指向待插结点,将前面结点指向待插结点
    技巧:这里可能结点指向操作的顺序容易弄混，导致出错.
    我的办法是，只要先把当前结点先分别指向后继结点和前继结点，然后再使前继结点和后继结点指向当前结点
    就一句话，记住先处理当前结点的指针域，顺序基本就不会错了。
*/
template <class T>
void DoubleLinkList<T>::Insert(int i,T x) {
    Node<T> *p = front;
    if(i!=1)
        p = GetNode(i-1);
    if(p) {
        Node<T> *s = new Node<T>;
        s->data = x;
        s->next = p->next; //指向后继结点
        s->pre = p;       //pre指针域指向前一结点
        p->next->pre = s;   //后继结点pre指向待插结点
        p->next = s;       //前一结点指向待插结点
    }

}
int main()
{
    int a[6] = {1,3,6,7,4,8};
    DoubleLinkList<int> list(a,6);
    cout<<"双向循环链表的长度为:"<<endl;
    cout<<list.GetLength()<<endl;
    cout<<"遍历双向循环链表"<<endl;
    list.PrintLinkList();
    cout<<"删除位置3的元素:"<<endl;
    cout<<"删除的元素为:"<<list.Delete(3)<<endl;
    list.PrintLinkList();
    cout<<"在位置3插入元素5"<<endl;
    list.Insert(3,5);
    list.PrintLinkList();
    return 0;
}
</span>

运行结果：