循环链表的实现

1. 什么是循环链表

1.1概念

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

1.2实现

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

2. 循环链表的逻辑构成

继承层次结构

3. 循环链表的实现思路

（1）通过模板定义CircleList类，继承自LinkList类

（2）定义内部函数makeCircle()，用于将单链表首尾相连

（3）特殊处理：首元素的插入操作和删除操作

　　①插入位置为0时：头结点和尾结点均指向新结点；新结点成为首结点。

　　②删除位置为0时：头结点和尾结点指向位置为1的结点；安全销毁首结点。

（4）重新实现：清空操作和遍历操作

【编程实验】循环链表的实现

//LinkList.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include "List.h"
namespace DataStructureLib
{
    template <typename T>

    class LinkList:public List<T>
    {
    protected:
        struct Node{
            T value;
            Node* next;
        };

        mutable Node m_header;//头结点 、mutable为了让get函数中的const属性导致的&m_header（编译器认为是要修改成员变量）mutable就允许const成员函数取地址
        int m_length;//链表的长度

        Node* position(int i) const//返回第i和元素的指针
        {
            Node* ret=&m_header;

            for(int p=0;p<i;p++)
            {
                ret=ret->next;
            }

            return ret;//元素地址保存在该节点的next指针域中
        }
        
        //游标
        int m_step;
        Node* m_current ;
    public:
        LinkList()
        {
            m_header.next=NULL;
            m_length=0;
            m_step=1;
            m_current=NULL;
        }
        bool insert(const T &elem) //O(n)
        {
            return insert(m_length, elem);
        }

        bool insert(int index, const T& elem)//思路：1.找到index位置处的元素；2.在该元素尾部insert新元素
        {
            bool ret=(index<=m_length)&&(index>=0);

            if (ret)
            {
                Node* NewNode=createNode() ;

                if (NULL!=NewNode)
                {
                    NewNode->value=elem;

                    Node* currentNode=position(index);
                    NewNode->next=currentNode->next;
                    currentNode->next=NewNode;

                    m_length++;
                }
                else{
                    throw("has Not enougth memory to insert new element ...");
                }

            }
            return ret;
        }

        bool remove(int index)
        {
            bool ret=((index<=m_length)&&(index>=0));

            if (ret)
            {
                Node* CurrentNode=position(index);
                Node* toDelNode=CurrentNode->next;
                if(this->m_current==toDelNode)
                {
                    this->m_current=toDelNode->next;
                }
                CurrentNode->next=toDelNode->next;

                delete toDelNode ;
                m_length--;
            }

            return ret;
        }
        
        bool set(int index,const T& e)
        {
            bool ret=((0<=index)&&(index<=m_length));

            if (ret)
            {
                Node* CurrentNode=position(index);
                CurrentNode->next->value=e;
            }
            
            return  ret; 
        }

        bool get(int index, T& elem) const
        {
            bool ret=((index<=m_length)&&(index>=0));

            if (ret)
            {
                Node* CurrentNode=position(index);
                elem= CurrentNode->next->value;
            }

            return ret;
        }

        T get(int index)
        {
            T ret;
            if((index<m_length)&&(0<=index))
            {
                Node* CurrentNode=position(index);
                ret= CurrentNode->next->value;
            }

            return ret; 
        }
        int getlength() const
        {
            return m_length;

        }

        void clear()
        {
                                
            while (m_header.next)
            {
                Node* toDelNode=m_header.next;
                m_header.next=toDelNode->next;
                delete toDelNode;
            }
            m_length=0;
        }
        
        //寻找e元素所在的位置，
        //返回值 失败：-1    成功：e元素所在的位置的id
        int find(T& e)
        { 
            int ret = -1;
            for (int i=0;i<m_length;i++)
            {
                if (e==get(i))
                {
                    ret=i;
                }
            }

            return ret;
        }   

        bool move(int i,int step=1)//将游标定位到目标位置，//i代表目标位置  step游标每次移动的节点的数目
        {
            bool ret= (0<=i)&&(i<m_length)&&(step>0);

            if (ret)
            {
                m_current=position(i)->next;
                m_step=step;
            }

        return ret;

        }

        bool end()//游标有无到达链表尾部
        {
            return (m_current==NULL);
        }

        T current()//获取游标所指向的数据元素
        {
            if(!end())
            {
                return  m_current->value ;
            }
            else
            {
                throw("No Value at current position...");
            }
        }

        //移动游标  相当于每次移动的大小m_step
        bool next()
        {

            int i=0;

            while ((m_step>i)&&(!end()))
            {
                m_current=m_current->next;
                i++;
            }

            return (i==m_step);
        }
        
        //封装节点创建和销毁函数，以便子类可以重载这个函数。
        virtual Node* createNode()
        {
            return new Node();
        }

        virtual void destroyNode(Node* pn)
        {
            delete pn;
        }
        
        ~LinkList()
        {
            clear();
        }
};
}
#endif

//CircleList.h

#ifndef CIRCLELIST_H
#define CIRCLELIST_H

#include "LinkList.h"

namespace DataStructureLib
{
    template <typename T>
    
    class CircleList:public LinkList<T>
    {
    protected:
        typedef typename LinkList<T>::Node Node ;//这种情况下要加上typename，因为不加编译器有可能将LinkList<T>::Node Node 试图
                                                //解释为变量，你在typedef 就会有语法错误。加上以后就是让编译器认为LinkList<T>::Node Node 它是一个类型 
    
        Node* last() const //
        {
            return this->position(m_length-1)->next;////返回指向尾结点指针
        }
    
        void makeCircleList() const {//尾节点的指针指向第一个节点（即首节点的指针域）
            if(this->m_header.next)
                last()->next=this->m_header.next;
        }

        int mod(int i)//判断循环链表中的第i个元素在链表的位置
        {
            return (this->m_length==0)?0:(i %this->m_length);   
        }

    public:
        bool insert(int index, const T& elem)
        {
            bool ret=true;

            index=index%(this->m_length+1);
        
            ret=LinkList<T>::insert(index,elem);
            if (ret && (index==0))
            {
                makeCircleList(); //首尾相连
            }

            return ret;
        }

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

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

            if (index==0) //删除0位置时
            {
                Node* toDel=this->m_header.next;
                if (toDel!=NULL)
                {
                    this->m_header.next=toDel->next;
                    this->m_length--;

                    if(this->m_length>0)
                    {
                        makeCircleList();
                        if(this->m_current==toDel)
                        {
                        this->m_current=toDel->next;
                        }
                    }
                    else
                    {
                        this->m_header.next=NULL;

                        this->m_current=NULL;
                    }

                    this->destroyNode(toDel);
                }
                else
                {
                    ret=false;
                }
            }

            else
            {
                LinkList<T>::remove(index);
            }



            return ret;
        }

        bool set(int index, const T& elem)
        {
            return LinkList<T>::set(mod(index), elem);
        }

        T get(int index) const
        {
            return LinkList<T>::get(mod(index));
        }

        bool get(int index, const T& elem) const
        {
            return LinkList<T>::get(mod(index), elem);
        }

        int find(const T& elem) const
        {
            int ret = -1;
            Node* slider = this->m_header.next;

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

                slider = slider->next;
            }

            return ret;
        }

        void clear()
        {
            if (this->m_length>1)
            {
                //remove(1)而不remove(0)是因为避开删除首结点
                //而导致效率低下的问题。
                remove(1);
            }
            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->destroyNode(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()
        {
            clear();
        }

    };

}
#endif

约瑟夫环问题

小故事

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

约瑟夫环

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

【编程实验】约瑟夫问题

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

using namespace std;  
using namespace DataStructureLib;  

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);  //游标指向0处，步长2

    int i=0;

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

        if (i%8==0)
        {
            cout<<'
';
        }
        
        cout <<"("<<++i<<")"<< cl.current() << "  ";  //当前要自杀的

        int index=cl.find(cl.current());
        cl.remove(index); 
    }  
}  

int main()  
{  
    josephus(41,1,3);  //41个人，从1号开始数，数到第三个人开始自杀

    return 0;  
}

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

4. 小结

（1）循环链表是一种特殊的单链表

（2）尾结点的指针域保存了首结点的地址

（3）特殊处理首元素的插入操作和删除操作

（4）重新实现清空操作和遍历操作