第二十九课 循环链表的实现

循环链表的继承层次结构：

插入位置为0图解：

 删除位置为0图解：

 添加CircleList.h文件：

#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   // 不能对0取余，需特殊处理
    {
        return (this->m_length == 0) ? 0 : (i % this->m_length);
    }

    // last获取最后一个节点的指针
    // position返回i-1个节点，再取next可以获取最后一个节点的指针
    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))
        {
            last_to_first();
        }

        return ret;
    }

    bool remove(int i)
    {
        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 )
                    {
                        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)
    {
        return LinkList<T>::set(mod(i), e);
    }

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

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

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

        //先变成单链表，这样就可以直接调用find了,find过后再恢复为循环链表
        //但是这是有问题的，因为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()
    {
        while( this->m_length > 1)
        {
            remove(1);   // 每次删除第一个元素，提高效率，每次删除第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();
    }
};

}

#endif // CIRCLELIST_H

我们将LinkList中的函数全部做成了virtual虚函数，因为有可能将CircleList当LinkList使用。在CircleList中我们重新实现了很多函数。

在重新实现的find函数中，120--122行也能实现功能，但是这不是异常安全的，先将循环链表变为单链表，然后查找，最后再变为循环链表。在查找的过程中有泛指类型T的比较操作，因此，有可能抛出异常。抛出异常后就无法变为循环链表了，破坏了循环链表，因此，不是异常安全的。为了移植性，我们也不选择使用try catch，而是重新实现了find函数。

mod函数要定义为const的，否则在get成员函数中使用mod会报错。

例如：

CircleList的clear函数也是重新实现，不能直接变为单链表，然后调用父类的clear，因为也存在异常安全性。

我们重新实现了clear，在m_length大于1时，每次删除第一个元素，这样可以提高效率。如果每次删除第0个元素，则还要涉及到 last_to_first操作，这时效率非常低的。

循环链表的应用：

测试程序如下：

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

    // 报数到m就自杀，也就是移动m-1次就自杀，因此，下面传入的参数是m-1
    cl.move(s-1, m - 1);

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

int main()
{
    //41个人玩游戏， 从1开始数数， 数到3就自杀
    josephus(41, 1, 3);

    return 0;
}

运行结果如下：

小结：