线性表的链式存储——循环单链表的实现

1，什么是循环链表：

       1，概念上：

              1，任意数据元素都有一个前驱和一个后继；

              2，所有的数据元素的关系构成一个逻辑上的环；

       2，实际上：

              1，循环链表是一种特殊的单链表；

              2，尾结点的指针域保存了首结点（不是头结点）的地址；

             

2，循环链表逻辑构成：

 

3，循环链表继承层次结构：

 

      

4，循环链表实现思路：

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

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

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

       4，重新实现：清空操作和遍历操作；

      

5，循环链表实现要点：

       1，插入位置为 0 时：

              1，头结点和尾结点均指向新结点；

              2，新结点成为首结点插入链表； 

       2，删除位置为 0 时：

              1，头结点和尾结点指向位置为 1 的结点；

              2，安全销毁首结点；

              3，删除首结点；

             

6，CircleList 循环链表的实现：

#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;

    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)，归一化 i；
    {
        return (this->m_length == 0)? 0 : (i % this->m_length);
　　 }

public:                                     // 这里都是父类的属性，所以不用构造；
    bool insert(const T& e)    // O(n)
    {
        return insert(this->m_length, e);   // 这里是可以插入到原来最后一个节点后面的，所以是为 this->m_length;
　　 }

    bool insert(int i, const T& e)    // O(n)，注意删除位置为 0 的操作；
    {
        bool ret = true;
        i = i % (this->m_length + 1);    // 这里是插入共 m_length + 1 个数字，归一化 i 的值，特意加 1，为了让最后的 m_length 位置不是在 0 位置处，这样才可以利用单链表；
        ret = LinkList<T>::insert(i, e);    // 取余是为了用父类实现子类；O(n)

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

        return ret;
　　 }

    bool remove(int i)     // 删除第 i 个节点   O(n)，要注意删除位置为 0 的操作
    {
        bool ret = true;
        i = mod(i);

        if( i == 0 )     // 为了应对首尾相连的情况
        {
            Node* toDel = this->m_header.next;

            if( toDel != NULL )   // 为了应对原生链表节点数为 0 的情况
            {
                this->m_header.next = toDel->next;   // 要连接到第二个节点上
                this->m_length--;

                if( this->m_length > 0 )  // 为了应对原生链表节点数大于 1 的情况
                {
                    last_to_first();   // O(n)

                    if (this->m_current == toDel )     // 使得当前节点不再指向被删除的节点
                    {
                        this->m_current = this->m_current->next;
                    }
                }
                else
                {
                    this->m_header.next = NULL;
                    this->m_current = NULL;
                }
            }
            else
            {
                ret = false;     // 删除节点为零的链表将产生错误
            }

            this->destroy(toDel);    // 异常安全
        }
        else
        {
            LinkList<T>::remove(i);  // 删除非 0 节点按照顺序表删除   o(n)
        }

        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));
　　 }

    T  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;
/*
        last()->next = NULL;
        ret = LinkList<T>::find(e);  // 如果 find() 中比较操作符在类中抛出异常，这里又没有 try() catch()，则会造成链表属性改变；
        last_to_first();
*/
        Node* slider = this->m_header.next;

        for(int i=0; i<this->m_length; i++)   // O(n)，遍历所有的结点；
        {
            if( slider->value == e )  // 相等操作抛出异常时，链表状态不会改变；
            {
                ret = i;
                break;
            }

            slider = slider->next;
        }

        return ret;
　　 }

    void clear()     // O(n)
    {
        while( this->m_length > 1 )  // O(n)
        {
            remove(1);   // O(1)，这里没有调用 remove(0) 是因为避免大量移动指针，提高效率；
        }

        if( this->m_length == 1 )     // O(1)
        {
            Node* toDel = this->m_header.next;
            this->m_header.next = NULL;
            this->m_current = NULL;
            this->m_length = 0;

            this->destroy( toDel );
        }
　　 }

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

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

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

}

#endif // CIRCLELIST_H

 

7，约瑟夫环测试 CircleLisnt：

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

using namespace std;
using namespace DTLib;

void josephus(int n, int s, int m)
{
　　 CircleList<int> c1;

    for(int i=1; i<=n; i++)
    {
        c1.insert(i);  // 这里插入的位置是 i - 1，值是 i；
　　 }

　　 c1.move(s-1, m-1);// 链表是从 0 开始的，所以为 s - 1; 移动  m - 1步,就到 m 了；

    while(c1.length() > 0)
    {
        c1.next();  // 每次移动 m - 1 步；
        cout << c1.current() << endl;       // 显示的最后两个人则可以活

        c1.remove(c1.find(c1.current()));  // 自杀了后从环中移除；
    }
}

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

    return 0;
}

 

8，有可能用 CircleList 代替 LinkList 工作，所以 LinkList 中的成员函数都要变成虚函数才可以，已经在“线性表的链式存储结构——单链表的实现”中的4 中实现；

 

9，循环链表的应用：

       1，约瑟夫环问题：

             

10，小结：

       1，循环链表是一种特殊的单链表；

       2，尾结点的指针域保存了首结点的地址；

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

       4，重新实现清空操作和遍历操作；