数据结构--循环链表

概念上的循环链表是任何数据元素都有一个前驱和一个后继，首结点的前驱是尾结点，尾结点的后继是首结点，所有数据元素的关系在逻辑上构成一个环，而单链表是除了首尾数据结点外都有前驱和后继。

实现上循环链表是一种特殊的单链表，在尾结点的指针域中保存了首结点的地址。

如图所示：

实现设计思路：

通过类模板实现。

继承自LinkList类。

定义指向最后一个结点的函数。

定义首尾相连的函数。

特殊处理在第0个结点位置的插入和删除操作。

重新实现清空和查找、遍历操作。

插入位置为0时：

头结点和尾结点均指向新结点。

新结点成为首结点插入链表。

删除位置为0时：

头结点和尾结点指向当前位置为1的结点。

保证异常安全的前提下销毁首结点。

类模板声明及定义：

template <typename T>
class CircleList : public LinkList<T>
{
  protected:
    typedef typename LinkList<T>::Node Node;

    int mod(int i)const//取余操作
    {
        return (this->m_length == 0) ? 0 : (i % this->m_length);
    }
    Node* last()const//指向最后一个数据结点
    {
        return this->position(this->m_length - 1)->next;//倒数第二个的下一个就是最后一个
    }
    void last_to_first()const//首尾结点连接起来
    {
        last()->next = this->m_header.next;
    }

public:
    bool insert(const T& e)
    {
        return insert(this->m_length,e);
    }

    bool insert(int i, const T& e)//插入操作
    {
        bool ret = true;
        i = i % (this->m_length + 1);//计算出需要插入的位置
        ret= LinkList<T> :: insert(i,e);//调用父类成员函数

        if(ret && (i == 0))//特殊处理插入位置为0的情况
        {

            last_to_first();
        }

        return ret;
    }

    bool remove(int i)
    {
        bool ret = true;
        i = mod(i);

        if(i == 0)特殊处理删除位置为0的结点
        {
            Node* toDel = this->m_header.next;//保存首结点
            if(toDel != NULL)
            {
                this->m_header.next = toDel->next;//头结点连接1号结点
                this->m_length--;
                if(this->m_length > 0)//判断是否只剩下一个结点
                {
                    last_to_first();
                    if(this->m_current == toDel)
                        this->m_current = toDel->next;
                }
                else
                {
                    this->m_header.next = NULL;
                    this->m_current = NULL;
                }
                this->destroy(toDel);//异常安全
            }
            else
            {
                ret = false;
            }
        }
        else
        {
            ret = LinkList<T>::remove(i);
        }
        return ret;
    }

    bool set(int i,const T& e)//调用父类set函数
    {
        return LinkList<T> :: set(mod(i),e);
    }
    T get(int i)const//调用父类get函数
    {
        return LinkList<T>::get(mod(i));
    }
    bool get(int i, T& e)const//此处实现和视频不同，视频在T&前加了const
    {
        return LinkList<T> :: get(mod(i),e);
    }

    /*
    *一开始提到的利用LinkList的find函数查找，先last指向NULL，再find，最后last_to_first，这样是不可靠的，当find里的比较操作符
    * 重载时抛出异常后，就会返回异常，最后链表状态也被改变了，成为了一个单链表
    */
    int find(const T& e)const
    {
        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;
    }

    /*
    *不能使用先将首节点指向NULL再LinkList<T>:: clear()
    * 当clear()抛出异常后就改变了链表状态
    */
    void clear()
    {

        while(this->m_length > 1)
        {
            this->remove(1);//remove(1)的好处是避免了使用remove(0)从而执行大量语句，拉低效率
        }
        if(this->m_length == 1)
        {
            Node* toDel = this->m_header.next;

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

            this->destroy(toDel);//异常安全
        }
    }

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

    bool end()
    {
        return (this->m_length == 0) || (this->m_current == NULL);
    }
    ~CircleList()
    {
        clear();
    }

};

注意：由于CircleList是LinkList的子类，当独立使用CircleList时就只调用子类的实现版本，所以将LinkList类的所有成员函数做成虚函数。

程序段中有关父类的调用请参考单链表LinkList类的实现。

测试题：约瑟夫换问题

已知n个人(以编号0，1,2,3.....n-1分别表示) 围坐在一张圆桌周围。从编号为k 的人开始报数，数到m 的那个人出列; 他的下一个人又从1开始报数，数到m 的那个人又出列; 依此规律重复下去，直到圆桌周围的人全部出列。

用循环链表实现如下：

void josephus(int num, int start, int step)//总数为num，从第start个开始，每数step个数出列
{
    CircleList<int> c1;

    for(int i = 1; i <= num; i++)
    {
        c1.insert(i);
    }

    c1.move(start-1, step-1);//每移动m-1次就可以到达目的，如三个一循环只需移动两个就能让第三个出列。

    while(c1.length() > 0)
    {
        c1.next();
        cout << c1.current() << endl;
        c1.remove(c1.find(c1.current()));
    }
}

在main里调用并输出：

3
6
1
5
2
8
4
7