循环链表 CircleList的实现并解决约瑟夫环问题

本篇分析一下LinkList的另一个子类CircleList的实现，可参考以下两篇博客：
（1）单链表LinkList的实现
（2）静态单链表StaticLinkList的实现

循环链表的定义

（1）概念上
1、任意数据元素都有一个前驱和一个后继；
2、所高的数1居元素的关系构成一个逻辑上的环。
（2）实现上
1、循环链表是一种特殊的的单链表；
2、尾结点的指针域保存了首结点的地址。

循环链表的逻辑构成

            

循环链表的实现思路

1、通过模板定义 CircleList 类，继承自 LinkList 类；
2、定义内部函数 last_to_first()，用于将单链表首尾相连；
3、特殊处理：考虑首元素的插入和删除操作（因为尾结点要指向首元素）；
4、重新实现清空操作和遍历操作。（因为在 LinkList 里面是根据尾结点的next指针为空作为结束标记来实现清空和遍历操作，循环链表里面的尾结点不是空）。

实现要点

重点考虑首元素的插入和删除操作。
插入位置为0的操作
（1）头结点和尾结点均指向新结点；
（2）新结点成为首结点插入链表。
删除位置为0的操作
（1）头结点和尾结点指向位置为 1 的结点；
（2）安全销毁首结点。
代码实现：

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

#include "LinkList.h"

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

        int mod(int i) const // O(1) 归一化取余即可（即使坐标不是从1而是从0开始）
        {
            return(this->m_length == 0) ? 0 : (i % this->m_length);
        }

        // 获得尾结点
        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;
        }
    public:
        bool insert(const T& e)          // O(n)
        {
            return insert(this->m_length, e);
        }

        bool insert(int i, const T& e)  // O(1) + O(n) + O(n) ==> O(2n+1) ==> O(n)
        {
            bool ret = true;

            i = i % (this->m_length + 1);  // O(1) 为什么加1？因为+1是代表 插入节点后该节点的相对位置（虽然此时未插入进去）不是现在循环链表的相对位置

            ret = LinkList::insert(i, e);   // O(n)

            if (ret && (i == 0))
            {
                last_to_first(); // 首尾相连 // O(n)
            }

            return true;
        }

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

            i = mod(i);

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

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

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

                        if (this->m_current == toDel) // 删除的结点正好是current所指向结点
                        {
                            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)   // O(n)
        {
            return LinkList<T>::set(mod(i), e);
        }

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

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

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

            // 把循环链表变成单链表不行，因为在LinkList<T>::find(e)中可能发生异常，
            // 这样就无法执行last_to_first()，导致循环链表的状态被损坏。需要重新实现find函数。
            /* 
            last()->next = NULL;

            ret = LinkList<T>::find(e);

            last_to_first();*/

            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()    // O(n+1) ==> O(n)
        {
            while (this->m_length > 1)  // O(n)
            {
                remove(1);  // 使用remove(1)因为remove(0)效率比较低  // O(1)
            }

            if (this->m_length == 1) // O(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)  // O(n)
        {
            return LinkList<T>::move(mod(i), step);
        }

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


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

    };
}

#endif

应用案例——用循环链表解决约瑟夫环问题

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

using namespace std;
using namespace DTLib;

void josephus(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); // 移动到s-1处，每一次移动m-1次

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

        cout << "Kill: " << cl.current() << endl;

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


}


int main(void)
{
    josephus(41, 1, 3);

    return 0;
}

运行结果：

所以，约瑟夫和他的朋友应该站在16和31这两个位置才能避免这次处决。