双向循环链表

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

在单链表中，查询一个结点的前驱需要从头指针出发，为克服单链表单向性的缺点，可以利用双向链表
双向链表的结点中有两个指针域，其中一个指向前驱，一个指向后继

用于测试的文件，以及测试结果可以去作者GitHub上查看

 （下面代码只是最初实现，后续如果有修改，由于太麻烦，不会再更改下文，仅仅更新Github上的代码文件）

具体实现：

// 双向循环链表
// 双向链表的结点
class DuLNode {
public:
    DuLNode() {
        data = INITDLNODE;
        prior = nullptr;
        next = nullptr;
    }

    DuLNode(ElemType ele, DuLNode *p, DuLNode *n) : data(ele), prior(p), next(n) {

    }

    ElemType data;
    DuLNode *prior;    // 指向前驱结点
    DuLNode *next;     // 指向后继结点
};

class DoubleLinkedList {
public:
    DoubleLinkedList();
    DoubleLinkedList(int len);
    ~DoubleLinkedList();

    DuLNode *DoubleLinkedListHead() {
        return head;
    }

    DuLNode *CListHead() {
        return head;
    }

    // 获取链表长度
    int DListLength();

    // 判断链表是否为空
    bool DListEmpty();

    // 返回链表中第pos个结点
    bool GetNode(int pos, DuLNode **node);

    // 返回指定data在链表中第一次出现的位置
    bool LocateNode(ElemType ele, DuLNode **node);

    // 在指定位置插入后一个结点，但若pos为0是表示在链表头插入一个结点
    bool DListInsert(int pos, DuLNode *node);

    // 删除指定位置结点
    bool DListDelete(int pos);

    // 删除指定位置结点并返回被删除结点的信息
    bool DListDelete(int pos, DuLNode *node);

    // 遍历线性表
    void DListTraverse();

    // 在链表尾添加cnt个结点
    bool DListAddNodes(int cnt);

    // 销毁链表，释放所有结点资源
    void DListDestory();

    // 查询某个节点是否在此链表中
    bool DListNodeIsInList(DuLNode *node);

    // 查询某个节点是否在此链表中，并返回其位置所在
    bool DListNodeIsInList(DuLNode *node, int *pos);

private:
    DuLNode *head;  
    // head作为双向循环链表的头结点，但其仅仅作为一个标志作用，该节点无数据域（其数据域数据无意义），且仅用于链表操作，并不作为逻辑上的链表节点
    // 逻辑上链表第一个结点为head指向的下一个结点
};

/*
注意：
    在上述实现中：
    链表头结点，不储存数据，在测试链表是否为空、计算链表长度时不包括该结点
    作为一个标志作用，该节点无数据域（其数据域数据无意义）
    在使用链表时注意此时操作的结点是否为head
    但在考虑链表中结点的前驱和后继时，head是第一个结点的前驱，最后一个结点的后继
*/

DoubleLinkedList::DoubleLinkedList()
{
    head = new DuLNode;
    head->prior = head;
    head->next = head;
}

DoubleLinkedList::DoubleLinkedList(int len)
{
    head = new DuLNode;
    head->prior = head;
    head->next = head;

    DListAddNodes(len);
}

DoubleLinkedList::~DoubleLinkedList()
{
    DListDestory();
    delete head;
}

bool DoubleLinkedList::DListEmpty()
{
    return (head == head->next) ? true : false;
}


int DoubleLinkedList::DListLength()  
{
    DuLNode *temp = head;
    int cnt = 0;

    while (head != temp->next) {
        cnt++;
        temp = temp->next;
    }

    return cnt;
}


bool DoubleLinkedList::GetNode(int pos, DuLNode **node)
{
    if (pos > DListLength() || pos < 1)
        return false;

    DuLNode *cur = head;

    for (int i = 1; i <= pos; i++) {
        cur = cur->next;
    }

    *node = cur;

    return true;
}


bool DoubleLinkedList::LocateNode(ElemType ele, DuLNode **node)
{
    DuLNode *curNode = head;

    while (head != curNode->next) {
        if (curNode->data == ele) {
            *node = curNode;
            return true;
        }

        curNode = curNode->next;
    }
    *node = nullptr;

    return false;
}


bool DoubleLinkedList::DListInsert(int pos, DuLNode *node)
{
    // 插入位置错误
    if (pos < 0 || pos > DListLength())
        return false;

    if (pos == 0) {
        node->next = head->next;
        node->prior = head;
        head->next = node;
    }
    else {
        DuLNode *temp = nullptr;
        this->GetNode(pos, &temp);
        node->next = temp->next;
        node->prior = temp;
        temp->next = node;
    }

    return true;
}

bool DoubleLinkedList::DListDelete(int pos)
{
    if (pos <1 || pos > DListLength())
        return false;

    // 由于每个结点可以获取其前驱结点信息，相对于单向循环链表的实现，下面实现更为简单
    DuLNode *del;
    GetNode(pos, &del);
    del->prior->next = del->next;
    del->next->prior = del->prior;
    delete(del);

    return true;
}


bool DoubleLinkedList::DListDelete(int pos, DuLNode *node)
{
    if (pos <1 || pos > DListLength())
        return false;

    // 由于每个结点可以获取其前驱结点信息，相对于单向循环链表的实现，下面实现更为简单
    DuLNode *del;
    GetNode(pos, &del);

    del->prior->next = del->next;
    del->next->prior = del->prior;
    // 返回所需数据
    node->data = del->data;
    node->prior = del->prior;
    node->next = del->next;
    delete(del);

    return true;
}


void DoubleLinkedList::DListTraverse()
{
    DuLNode *curNode = head->next;

    while (curNode != head) {
        std::cout << curNode->data << std::endl;
        curNode = curNode->next;
    }
}


bool DoubleLinkedList::DListAddNodes(int cnt)
{
    if (cnt < 0)
        return false;
    else if (cnt == 0)
        return true;

    DuLNode *lastNode = head->prior;  // 获取最后一个结点

    for (int i = 0; i < cnt; i++) {
        ElemType temp;
        std::cin >> temp;
        DuLNode *node = new DuLNode(temp, nullptr, nullptr);

        if (!node) {
            return false;
        }

        lastNode->next = node;
        node->prior = lastNode;
        node->next = head;
        lastNode = node;
    }

    return true;
}


void DoubleLinkedList::DListDestory()
{
    DuLNode *cur = head->next;
    DuLNode *next = cur->next;

    while (head != cur) {
        delete cur;
        cur = next;
        next = next->next;
    }
}

bool DoubleLinkedList::DListNodeIsInList(DuLNode *node)
{
    DuLNode *cur = head->next;

    while (cur != head) {
        if (cur == node) {
            return true;
        }

        cur = cur->next;
    }

    return false;
}

bool DoubleLinkedList::DListNodeIsInList(DuLNode *node, int *pos)
{
    DuLNode *cur = head->next;
    int cnt = 0;

    while (cur != head) {
        cnt++;

        if (cur == node) {
            *pos = cnt;
            return true;
        }

        cur = cur->next;
    }

    return false;
}