【数据结构】29_循环链表的实现

什么是循环链表

• 概念上

  • 任意数据元素都有一个前驱和一个后继
  • 所有的数据元素的关系构成一个逻辑上的环

• 实现上

  • 循环链表是一种特殊的单链表
  • 尾结点的指针域保存了首结点的地址

循环链表的逻辑构成

循环链表的继承层次结构

循环链表的实现思路

• 通过模板定义 CircleList 类，继承自LinkList
• 定义内部函数 last_to_first() 用于将单链表首尾相连
• 特殊处理：首元素的插入和删除操作
• 重新实现：清空和遍历操作

循环链表的实现要点

• 插入位置为 0 时：

  • 头结点和尾结点均指向新结点
  • 新结点成为首结点插入链表

• 删除位置为 0 时：

  • 头结点和尾结点指向位置为 1 的结点
  • 安全销毁首结点

编程实验：循环链表的实现

文件：CircleList.h

#ifndef CIRCLELIST_H
#define CIRCLELIST_H

#include "LinkList.h"

namespace DTLib
{

template <typename T>
class CircleList : public LinkList<T>
{
public:
    bool insert(const T &e) override  // O(n)
    {
        return insert(this->m_length, e);
    }

    bool insert(int i, const T &e) override  // O(n)
    {
        bool ret = true;
        i = i % (this->m_length + 1);

        ret = LinkList<T>::insert(i, e);

        if (ret && (i == 0))
        {
            last_to_first();
        }

        return ret;
    }

    bool remove(int i) override // O(n)
    {
        bool ret = true;
        i = mod(i);

        if (i == 0)
        {
            Node *toDel = this->m_header.next;

            if (toDel != nullptr)
            {
                this->m_header.next = toDel->next;
                --this->m_length;

                if (this->length() > 0)
                {
                    last_to_first();

                    if (this->m_current == toDel)
                    {
                        this->m_current = this->m_current->next;
                    }
                }
                else
                {
                    this->m_header.next = nullptr;
                    this->m_current = nullptr;
                }

                this->destroy(toDel);
            }
            else
            {
                ret = false;
            }
        }
        else
        {
            ret = LinkList<T>::remove(i);
        }

        return ret;
    }

    bool set(int i, const T &e) override  // O(n)
    {
        return LinkList<T>::set(mod(i), e);
    }

    T get(int i) const override  // O(n)
    {
        return LinkList<T>::get(mod(i));
    }

    bool get(int i, T &e) const override  // O(n)
    {
        return LinkList<T>::get(mod(i), e);
    }

    int find(const T &e) const // O(n)
    {
        int ret = -1;

        Node *slider = this->m_header.next;

        for (int i=0; i<this->m_length; ++i)
        {
            if (slider->value == e)
            {
                ret = i;
                break;
            }

            slider = slider->next;
        }

        return ret;
    }

    void clear() override  // O(n)
    {
        while (this->m_length > 1)
        {
            remove(1);  // 注意：为了效率，没有调用 remove(0)！
        }

        if(this->m_length == 1)
        {
            Node *toDel = this->m_header.next;

            this->m_header.next = nullptr;
            this->m_current = nullptr;
            this->m_length = 0;

            this->destroy(toDel);
        }
    }

    bool move(int i, int step = 1)  // O(1)
    {
        return LinkList<T>::move(mod(i), step);
    }

    bool end()  // O(n)
    {
        return ((this->m_length == 0) || (this->m_current == nullptr));
    }

    ~CircleList()  // O(n)
    {
        clear();
    }

protected:
    using Node = typename LinkList<T>::Node;

    Node *last() const // O(n)
    {
        return this->position(this->m_length - 1)->next;
    }

    void last_to_first() const // O(n)
    {
        last()->next = this->m_header.next;
    }

    int mod(int i) const // O(1)
    {
        return (this->m_length == 0) ? 0 : (i % this->m_length);
    }
};

}

#endif // CIRCLELIST_H

循环链表的应用

小故事：
在罗马人占领乔塔伯特后，39个犹太人与Josephu及他的朋友躲在一个洞中，39个犹太人决定宁愿死也不要被敌人抓住，于是决定了一个自杀方式，41个人排成一个圆环，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然后Josephus和他的朋友并不想遵从。那么，一开始要站在什么地方才能避免被处决？

约瑟夫环问题
已知n个人（以编号 0,1,2,3,...,n-1）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依次规律重复下去，直到圆桌周围的人全部出列。

编程实验：约瑟夫问题

文件:main.cpp

#include <iostream>
#include "CircleList.h"

using namespace std;
using namespace DTLib;

void jsoephus(int n, int s, int m)
{
    CircleList<int> cl;

    for (int i=1; i<=n; ++i)
    {
        cl.insert(i);
    }

    cl.move(s-1, m-1);

    while (cl.length() > 0)
    {
        cl.next();

        cout << cl.current() << " ";

        cl.remove(cl.find(cl.current()));
    }

}

int main()
{
    jsoephus(41, 1, 3);

    return 0;
}

输出：

3 6 9 12 15 18 21 24 27 30 33 36 39 1 5 10 14 19 23 28 32 37 41 7 13 20 26 34 40 8 17 29 38 11 25 2 22 4 35 16 31

小结

• 循环链表是一种特殊的单链表
• 尾结点的指针域保存了首结点的地址
• 特殊处理首元素的插入和删除操作
• 重新实现清空操作和遍历操作

以上内容整理于狄泰软件学院系列课程，请大家保护原创！

---

链表的遍历方式 (针对 DTLib 中的循环链表)

Error:

for (dl.move(0); !dl.end(); dl.next())
{
    cout << dl.current() << " ";
}

Right:

dl.move(0);
for (int i=0; i<dl.length(); ++i)
{
    cout << dl.current() << " ";
    dl.next();
}