双向循环链表

// main.cpp

#include "DoublyCircularLinkedList.cpp"
#include <iostream>
using namespace std;

int main()
{
    int r[5] = {1, 2, 3, 4, 5};
    DoublyCircularLinkedList<int> L(r, 5);
    // DoublyCircularLinkedList<int> L(r, 0);

    cout << "链表长度：" << L.Length() << endl;

    cout << "执行插入操作前数据为：" << endl;
    L.PrintList(); //显示链表中所有元素
    try
    {
        L.Insert(2, 3); //在第2个位置插入值为3的元素
    }
    catch (const char *s)
    {
        cout << s << endl;
    }
    cout << "执行插入操作后数据为：" << endl;
    L.PrintList(); //显示双向循环链表的所有元素

    cout << "值为5的元素位置为：";
    cout << L.Locate(5) << endl; //查找元素5,并返回在表中位置

    cout << "执行删除操作前数据为：" << endl;
    L.PrintList(); //显示双向循环链表的所有元素
    try
    {
        L.Delete(1); //删除第1个元素
    }
    catch (const char *s)
    {
        cout << s << endl;
    }
    cout << "执行删除操作后数据为：" << endl;
    L.PrintList(); //显示双向循环链表的所有元素

    return 0;
}

// DoublyCiucularLinkedList.h

#ifndef _DOUBLYCIRCULARLINKEDLIST_H
#define _DOUBLYCIRCULARLINKEDLIST_H 1

template <class DataType>
struct Node // 链表的节点
{
    DataType data;
    Node<DataType> *prev, *next;
};

// 双向链表：带头节点
// 以下是类DoublyCircularLinkedList的声明
template <class DataType>
class DoublyCircularLinkedList
{
public:
    DoublyCircularLinkedList();                    // 建立只有头结点的空链表
    DoublyCircularLinkedList(DataType a[], int n); // 建立有n个元素的双向链表
    ~DoublyCircularLinkedList();                   // 析构函数
    int Locate(DataType x);                        // 在双向链表中查找值为x的元素序号
    void Insert(int i, DataType x);                // 在第i个位置插入元素值为x的结
    DataType Delete(int i);                        // 在双向链表中删除第i个结点
    void PrintList();                              // 按序号依次输出各元素
    int Length();                                  // 返回链表长度
private:
    Node<DataType> *first, *last; // 双向链表的头指针和尾指针
    int length;                   // 双向链表的长度
};

#endif /* _DOUBLYCIRCULARLINKEDLIST_H */

// DoublyCircularLinkedList.cpp

#include "DoublyCircularLinkedList.h"
#include <iostream>
using namespace std;

template <typename DataType>
DoublyCircularLinkedList<DataType>::DoublyCircularLinkedList() // 建立只有头结点的空链表
{
    first = new Node<DataType>, last = new Node<DataType>;
    first->prev = last->next = NULL;
    first->next = last;
    last->prev = first;
    length = 0;
}

template <typename DataType>
DoublyCircularLinkedList<DataType>::DoublyCircularLinkedList(DataType a[], int n) // 建立有n个元素的双向循环链表
{
    if (n < 0)
        throw "length < 0";
    first = new Node<DataType>, last = new Node<DataType>;
    first->prev = last->next = NULL;
    first->next = last;
    last->prev = first;
    Node<DataType> *p = first, *s;
    for (int i = 0; i < n; i++)
        s = new Node<DataType>{a[i], p, NULL}, p->next = s, p = s;
    p->next = last;
    last->prev = p;
    first->next->prev = last->prev;
    last->prev->next = first->next;
    length = n;
}

template <typename DataType>
DoublyCircularLinkedList<DataType>::~DoublyCircularLinkedList() // 析构函数
{
    if (!length)
    {
        delete first, last;
        return;
    }

    for (Node<DataType> *p = first->next, *pre = first;; pre = p, p = p->next)
    {
        delete pre;
        if (p == last->prev)
            break;
    }
    delete last;
}

template <typename DataType>
int DoublyCircularLinkedList<DataType>::Locate(DataType x) // 在双向循环链表中查找值为x的元素序号
{
    Node<DataType> *p = first->next;
    for (int i = 1; i <= length; i++, p = p->next)
        if (p->data == x)
            return i;
    return 0;
}

template <typename DataType>
void DoublyCircularLinkedList<DataType>::Insert(int i, DataType x) // 在第i个位置插入元素值为x的结
{
    if (i <= 0)
        throw "位置";
    if (!length)
    {
        Node<DataType> *p = new Node<DataType>{x, NULL, NULL};
        p->prev = p->next = p;
        first->next = last->prev = p;
        length = 1;
        return;
    }
    i %= length;
    if (!i)
        i = length;
    Node<DataType> *p;
    if (i <= length / 2)
    {
        p = last->prev;
        for (int j = 1; j <= i; j++)
            p = p->next;
    }
    else
    {
        p = first->next;
        for (int j = length; j >= i; j--)
            p = p->prev;
    }
    Node<DataType> *s = new Node<DataType>{x, p->prev, p};
    p->prev = p->prev->next = s;
    length++;
    if (i == 1)
        first->next = s;
    if (i == length)
        last->prev = s;
}

template <typename DataType>
DataType DoublyCircularLinkedList<DataType>::Delete(int i) // 在双向循环链表中删除第i个结点
{
    if (i <= 0)
        throw "位置";
    if (!length)
        throw "表空";
    i %= length;
    if (!i)
        i = length;
    Node<DataType> *p;
    if (i <= length / 2)
    {
        p = last->prev;
        for (int j = 1; j <= i; j++)
            p = p->next;
    }
    else
    {
        p = first->next;
        for (int j = length; j >= i; j--)
            p = p->prev;
    }
    DataType ans = p->data;
    p->prev->next = p->next;
    p->next->prev = p->prev;
    if (i == 1)
        first->next = p->next;
    if (i == length)
        last->prev = p->prev;
    delete p;
    length--;
    return ans;
}

template <typename DataType>
void DoublyCircularLinkedList<DataType>::PrintList() // 按序号依次输出各元素
{
    if (!length)
    {
        cout << "\n";
        return;
    }
    for (Node<DataType> *p = first->next;; p = p->next)
    {
        cout << p->data << " ";
        if (p == last->prev)
            break;
    }
    cout << "\n";
}

template <typename DataType>
int DoublyCircularLinkedList<DataType>::Length() { return length; }