双向循环链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

---

具体代码实现部分功能：
#ifndef GUARD_DBLNODE_h
#define GUARD_DBLNODE_h
#define NULL 0
template<class T>
struct DblNode{
    //数据成员
    T data;
    DblNode<T>* next;
    DblNode<T>* prior;
    //构造函数
    DblNode();
    DblNode(T e,DblNode* priorlink=NULL,DblNode* nextlink=NULL);
};

template<class T>
DblNode<T>::DblNode(){
    prior=NULL;
    next=NULL;
}

template<class T>
DblNode<T>::DblNode(T e,DblNode* priorlink,DblNode* nextlink){
    data=e;
    next=nextlink;
    prior=priorlink;
}

#endif
#ifndef GUARD_DBLLINKLIST_h
#define GUARD_DBLLINKLIST_h
#include"DblNode.h"
#include"iostream"
template<class T>
class DblLinkList{
protected:
    //双向循环链表数据成员
    DblNode<T>* head;
    int length;
public:
    DblLinkList();
    DblLinkList(T v[],int n);
    virtual~DblLinkList();
    int GetLength()const;
    bool IsEmpty()const;
    void Clear();
    int LocateElem(const T& e);//元素定位
    bool GetElem(int i)const;//取指定位置的元素
    bool SetElem(int i,const T& e);//修改指定位置的元素
    bool DeleteElem(int i);//删除元素
    bool InsertElem(int i,const T& e);//在任意位置插入元素
    bool InsertEnd(const T& e);//在表尾插入元素；
    DblLinkList(const DblLinkList<T>& x);//复制构造函数
    DblLinkList<T>& operator=(const DblLinkList<T>& x);//重载赋值运算
    void Traverse(void(*Visit)(const T&))const;//对元素遍历，具体的操作另外定义函数Visit,函数指针
};
template<class T>
DblLinkList<T>::DblLinkList(){
    head=new DblNode<T>;
    head->prior=head->next=head;//表头的前驱后继都指向头节点
    length=0;
}

template<class T>
DblLinkList<T>::DblLinkList(T v[],int n){
    DblNode<T>* p;
    p=head=new DblNode<T>;//构造头节点
    for(int i=0;i<n;i++){
        p->next=new DblNode<T>(v[i],p);
        p=p->next;
    }
    length=n;
    head->prior=p;//头节点的前驱指向尾节点，尾节点的next指向头结点
    p->next=head;//尾节点的next指向头节点
}

template<class T>
DblLinkList<T>::~DblLinkList(){
    Clear();
    delete head;
}

template<class T>
void DblLinkList<T>::Clear(){
    while(length>0)
        DeleteElem(1);//当链表不为空时，则删除其第一个元素
}

template<class T>
int DblLinkList<T>::LocateElem(const T&e){
    DblNode<T>* p=head->next;
    int count=1;
    while(p!=head&&p->data!=e){
        p=p->next;
        count++
    }
    if(p!=head)
        return count;
    else
        return 0;
}

template<class T>
bool DblLinkList<T>::GetElem(int i)const{
    DblNode<T>*p=head->next;
    int count=;
    if(i<1||i>length){
        std::cout<<"RANGE＿OVER"<<std::endl;
        return false;
    }else{
        for(count=1;count<i;count++)
            p=p->next;
        std::cout<<"the ith value is: "<<p->data<<std::endl;
        return true;
    }

}

template<class T>
bool DblLinkList<T>::SetElem(int i,const T& e){
    DblNode<T>*p=head->next;
    int count=1;
    if(i<1||i>length){
        std::cout<<"RANGE_OVER"<<std::endl;
        return false
    }else{
        for(count;count!=i;count++){
            p->next=p;
        }
        p->data=e;
        std::cout<<"SUCCESS"<<std::endl;
        return true;
    }
}

template<class T>
bool DblLinkList<T>::DeleteElem(int i){
    DblNode<T>* p=head->next;
    int count=1;
    if(i<1||i>length){
        std::cout<<"RANG_OVER"<<std::endl;
        return false;
    }else{
        for(count;count!=i;i++)
            p=p->next;
        p->prior->next=p->next;//P的前驱节点的NEXT指向P的后继节点；
        p->next->prior=p->prior;//p的后继节点的prior指向p的前驱节点；
        delete p;
        length--;
        std::cout<<"SUCCESS"<<std::endl;
        return true;
    }
}

template<class T>
bool DblLinkList<T>::InsertElem(int i,const T& e){
    DblNode<T>* p=head->next,*q;
    int count=1;
    if(i<1||i>length+1){
        std::cout<<"RANGE_OVER"<<std::endl;
        return false;
    }else{
        for(count;count!=i;i++)
            p=p->next;
        q=new Node<T>(e,p->prior,p);
        p->prior->next=q;//p的前驱节点的next指向q节点
        p->prior=q;//p的prior指向q节点；
        length++;
        std::cout<<"SUCCESS"<<std::endl;
        return true;
    }
}

template<class T>
bool DblLinkList<T>::InsertEnd(const T&e){
    DblLinkList<T>* p;
    p=new DblListLink<T>(e,head->prior,head);
    head->prior->next=p;
    head->prior=p;
    length;
    return true;

}
template<class T>
void DblLinkList<T>::Traverse(void(*Visit)(const T&))const{
    DblNode<T>* p;
    for(p=head->next;p!=head;p=p->next)
        (*Vist)(p->data);//对每个元素调用函数（*Visit）
}
#endif