C++双向循环链表

先说一说双向循环链表的逆置，网上搜了一箩筐，用VS2017，基本上不成功，尽管明白道理是怎么回事，但是总感觉，不像c++的类，感觉用起来还得传指针啊，传链表啊等参数，不太像双向循环链表类的专属函数。虽然c语言写出来双向循环链表最好，但是既然学了c++，就尽量用一下c++的特点，能用多少是多少，也有利于对c++理解。好了废话不多说，凉一凉自己写的一般一般的双向循环链表吧。

#include<iostream>

using namespace std;

template<class T> class DoubleLinkedList;

template<class T>
class MyNode    
{
    friend class DoubleLinkedList<T>;
private:
    T elem;
    MyNode *prev;
    MyNode *next;
    MyNode(){}
    MyNode(const T &theelem)
        :elem(theelem) {
        prev = NULL;
        next = NULL;
    }
};

template<class T>
class DoubleLinkedList
{
public:
    DoubleLinkedList() 
    {
        first = new MyNode<T>(); 
        first->prev = first->next = first;
    }
    ~DoubleLinkedList(){ makeEmpty(); }

    bool IsEmpty(); // 判断链表是否为空
    void makeEmpty(); // 清空链表
    int  Length(); // 计算链表的长度
    void Insert(int index, const T &x); // 按照索引插入值（节点）
    void Push_head(const T &x); // 向链表的头部插入值  头插法
    void Push_back(const T &x); // 向链表的尾部插入值  尾插法
    void Delete(T x); // 按值删除节点
    void Index_Delete(const int &n); // 按索引删除节点
    void Invert(); // 逆置
    void Concatenate(DoubleLinkedList<T> &b); // 连接链表
    void show(); // 显示链表，这只是方便，一般得做成迭代器
private:
    MyNode<T> *first;
};
template<class T>
bool DoubleLinkedList<T>::IsEmpty()
{
    return first == NULL;
}

template<class T>
void DoubleLinkedList<T>::makeEmpty()
{
    MyNode<T> *p;
    MyNode<T> *pNode = first->next;
    while (pNode != first)
    {
        p = pNode;
        pNode = pNode->next;
        delete p;
    }
    delete first;
    first = NULL;
}

template<class T>
int  DoubleLinkedList<T>::Length()
{
    int size = 0;
    MyNode<T> * p = first->next;
    if (IsEmpty()) cout << "The size is 0" << endl;
    else
    {
        while (p != first)
        {
            size++;
            p = p->next;
        }
    }
    return size;
}

template<class T>
void DoubleLinkedList<T>::Insert(int index, const T &x)
{
    MyNode<T> * insertNode = new MyNode<T>(x);
    MyNode<T> * p = first->next;
    if (Length() < index) {
        Push_back(x);
        return;
    }
    if (index < 1) {
        Push_head(x);
        return;
    }
    int count = 1;
    while (count < index && p != first)
    {
        count++;
        p = p->next;
    }
    insertNode->next = p;
    p->prev->next = insertNode;
    insertNode->prev = p->prev;
    p->prev = insertNode;
    return;
}

template<class T>
void DoubleLinkedList<T>::Push_head(const T &x)
{
    MyNode<T>* newNode = new MyNode<T>(x);
    newNode->prev = first;
    newNode->next = first->next;
    first->next->prev = newNode;
    first->next = newNode;
}

template<class T>
void DoubleLinkedList<T>::Push_back(const T &x)
{
    MyNode<T>* newNode = new MyNode<T>(x);
    newNode->prev = first->prev;
    newNode->next = first;
    first->prev->next = newNode;
    first->prev = newNode;
}

template<class T>
void DoubleLinkedList<T>::Delete(T x)
{
    MyNode<T>* p = first->next;
    while (p->elem != x && p != first)
    {
        p = p->next;
    }
    p->next->prev = p->prev;
    p->prev->next = p->next;
    delete p;
    return;
}

template<class T>
void DoubleLinkedList<T>::Index_Delete(const int &n)
{
    MyNode<T>* del = NULL;
    MyNode<T>* p = first->next;
    int count = 0;
    if (n < 0)
    {
        del = p;
        p->next->prev = first;
        first->next = p->next;
        delete del;
        return;
    }
    else if(n > Length())
    {
        del = first->prev;
        first->prev = del->prev;
        del->prev->next = first;
        delete del;
        return;
    }
    while (count < n && p != first)
    {
        count++;
        p = p->next;
    }
    del = p;
    p->next->prev = p->prev;
    p->prev->next = p->next;
    delete del;
}

template<class T>
void DoubleLinkedList<T>::Invert()
{
        // 我这里只考虑链表至少有一个实数节点的情况
        // 让p指向下一个节点，再把首节点与第一个实数节点做成一个循环链表，
    MyNode<T>* p = first->next;
    MyNode<T>* q = p;
    p = p->next;
    first->prev = q;
    q->next = first;

       // 只要把接下来的节点一个一个放到头部就行了
    while (p != first)
    {
        MyNode<T> *r;
        r = p;
        p = p->next;
        r->prev = first;
        r->next = first->next;
        first->next->prev = r;
        first->next = r;
    }
}

// 我选择将循环链表b的数值直接放到所连接链表的后面，这样改变b就不会改变连接后的链表

template<class T>
void DoubleLinkedList<T>::Concatenate(DoubleLinkedList<T> &b)
{
    MyNode<T>* p = b.first;
    
    if(IsEmpty())
    {
        first = p;
    }
    else if(b.IsEmpty())
    {
        return;
    }
    else {
        while (p->next != b.first)
        {
            p = p->next;
            Push_back(p->elem);
        }
        return;
    }
    return;
}

template<class T>
void DoubleLinkedList<T>::show()
{
    if (IsEmpty())
    {
        return;
    }
    MyNode<T>* p=first->next;
    while (p != first)
    {
        cout << p->elem << " ";
        p = p->next;
    }
    cout << endl;

}

// 下面测试的代码没啥可看的

int main()
{
    cout << "hello world!" << endl;

    DoubleLinkedList<int> a;
    a.Push_head(30);
    a.Push_head(20);
    a.Push_head(10);
    a.Push_back(40);
    a.Push_back(50);
    a.Push_back(60);
    a.Index_Delete(2);
    a.show();
    a.Insert(1, 35);
    a.Insert(-1, 100);
    a.show();
    int size;
    
    a.Delete(100);
    size = a.Length();
    a.Index_Delete(20);
    a.show();
    cout << "size: " << size << endl;

    DoubleLinkedList<int> intList;
    DoubleLinkedList<int> intList1;

    intList.Push_back(1);
    intList.Push_back(2);
    intList.Push_back(3);
    intList.Push_back(4);

    intList1.Push_back(5);
    intList1.Push_back(6);
    intList1.Push_back(7);
    intList1.Push_back(8);
    intList.Concatenate(intList1);
    intList.show();
    intList.Invert();
    intList.show();
    intList.Push_head(125);
    intList.Push_back(21);
    intList.Invert();
    intList.show();
    intList1.Delete(5);
    intList1.Delete(6);
    intList1.Delete(7);
    intList1.Delete(8);
    intList1.show();
    return 0;
}