约瑟夫问题的求解——利用循环链表

时间：2016-05-07 06:51:27 阅读：169 评论：0 收藏：0 [点我收藏+]

标签：

约瑟夫问题——利用循环链表求解

1. 约瑟夫问题的提法

约瑟夫问题（约瑟夫环）是一个数学的应用问题。
已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列，他的下一个人又从1开始报数，数到m的那个人又出列，依此规律重复下去，直到圆桌周围的人全部出列。
通常解决这类问题时我们把编号从1~n，最后结果编号即为原问题的解。

2. 求解约瑟夫问题的算法原理示例

注：n=8，m=3的约瑟夫问题示例，若n=8，k=1，m=3，则出列的顺序将为3，6，1，5，2，8，4，最初编号为7的就是约瑟夫问题的解。
(1)一群人围在一起坐成环状，一共8个人，n=8。
(2)从某个编号开始报数，假设从第一个人开始报数，k=1。
(3)数到某个数的时候，此人出列，下一个人重新报数，设定出列的报数为3，m=3。
(4)一直循环，直到所有人出列，约瑟夫环结束。
约瑟夫问题求解过程示例图：

3. 利用循环链表求解约瑟夫问题

3.1 循环链表的结点头文件

LinkNode.h


#ifndef LINK_NODE_H_


#define LINK_NODE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *link;  //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
};


#endif /* LINK_NODE_H_ */

3.2 循环链表的头文件(带附加头结点的实现)

CircularLinkedList.h


#ifndef CIRCULAR_LINKED_LIST_H_


#define CIRCULAR_LINKED_LIST_H_



#include "LinkNode.h"


template <class T>
class CircularLinkedList//带附加头结点
{
public:
    CircularLinkedList();                               //构造函数
    CircularLinkedList(const CircularLinkedList<T>& L); //拷贝构造函数
    ~CircularLinkedList();                              //析构函数
public:
    int Length()const;                          //计算链表的结点总数(除附加头结点)
    LinkNode<T>* Search(const T& x)const;       //搜索数据值为x的结点并返回
    LinkNode<T>* Locate(int i)const;            //获取第i个结点并返回
    bool GetData(int i, T& x)const;             //获取第i个结点的数据值保存至x，并返回获取成功与否
    bool SetData(int i, const T& x);            //修改第i个结点的数据值为x
    bool Insert(int i, const T& x);             //在第i个结点后插入数据值为x的新结点
    bool Remove(int i, T& x);                   //删除第i个结点，并将被删结点的数据值保存至x
    bool IsEmpty()const;                        //判断表是否为空
    bool IsFull()const;                         //判断表是否为满
    void Sort();                                //表排序——冒泡排序
    void InputFront(const T& endTag);           //前插法建立链表
    void InputRear(const T& endTag);            //后插法建立链表
    void Output()const;                         //输出所有结点的数据值
    void Reverse();                             //链表逆置
    void MakeEmpty();                           //清空链表(保留附加头结点)
    CircularLinkedList<T>& operator=(const CircularLinkedList<T>& L);   //链表间赋值操作——重载等号运算符
public:
    LinkNode<T>* GetHead()const;                //返回附加头结点的地址
    T get_value(string& s_value);               //返回输入的结点数据值                
public:
    static bool IsNumber(const string& s_num);  //判断输入的字符串每个字符是否都是数值0~9
    static T StrToTtype(const string& s_num);   //类型转换——将string型转为模板类型T
private:
    LinkNode<T> *first; //链表的头结点
};

//构造函数
template<class T>
CircularLinkedList<T>::CircularLinkedList()
: first(new LinkNode<T>)
{
    first->link = first;
    cout << "$ 执行构造函数" << endl;
}

//拷贝构造函数
template<class T>
CircularLinkedList<T>::CircularLinkedList(const CircularLinkedList<T>& L)
{
    cout << "$ 执行拷贝构造函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (L.GetHead() != srcptr->link)
    {
        srcptr = srcptr->link;
        destptr->link = new LinkNode<T>(srcptr->data);
        destptr = destptr->link;
    }
    destptr->link = first;
}

//析构函数
template<class T>
CircularLinkedList<T>::~CircularLinkedList()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}

//计算链表的结点总数(除附加头结点)
template<class T>
int CircularLinkedList<T>::Length()const
{
    int count = 0;
    LinkNode<T> *curNode = first->link;
    while (first != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//搜索数据值为x的结点并返回
template<class T>
LinkNode<T>* CircularLinkedList<T>::Search(const T& x)const
{
    LinkNode<T> *curNode = first->link;
    while ((first != curNode) && (x != curNode->data))
    {
        curNode = curNode->link;
    }
    if (first == curNode)
    {
        curNode = NULL;
    }
    return curNode;
}

//获取第i个结点并返回
template<class T>
LinkNode<T>* CircularLinkedList<T>::Locate(int i)const
{
    if (i < 0)
    {
        return NULL;
    }
    if ((first == first->link) || (0 == i))
    {
        return first;
    }
    int location = 1;
    LinkNode<T> *curNode = first->link;
    while ((location < i) && (first != curNode))
    {
        curNode = curNode->link;
        location++;
    }
    if (first == curNode)
    {
        curNode = NULL;
    }
    return curNode;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否
template<class T>
bool CircularLinkedList<T>::GetData(int i, T& x)const
{
    LinkNode<T> *curNode = Locate(i);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    x = curNode->data;
    return true;
}

//修改第i个结点的数据值为x
template<class T>
bool CircularLinkedList<T>::SetData(int i, const T& x)
{
    LinkNode<T> *curNode = Locate(i);
    if ((NULL == curNode) || (first == curNode))
    {
        return false;
    }
    curNode->data = x;
    return true;
}

//在第i个结点后插入数据值为x的新结点
template<class T>
bool CircularLinkedList<T>::Insert(int i, const T& x)
{
    LinkNode<T> *curNode = Locate(i);
    if (NULL == curNode)
    {
        return false;
    }
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        cerr << "* 存储分配错误" << endl;
        exit(1);
    }
    newNode->link = curNode->link;
    curNode->link = newNode;
    return true;
}

//删除第i个结点，并将被删结点的数据值保存至x
template<class T>
bool CircularLinkedList<T>::Remove(int i, T& x)
{
    LinkNode<T> *preNode = Locate(i - 1);
    if (NULL == preNode)
    {
        return false;
    }
    LinkNode<T> *delNode = preNode->link;
    if ((NULL == delNode) || (first == delNode))
    {
        return false;
    }
    preNode->link = delNode->link;
    x = delNode->data;
    delete delNode;
    return true;
}

//判断表是否为空
template<class T>
bool CircularLinkedList<T>::IsEmpty()const
{
    return (first == first->link) ? true : false;
}

//判断表是否为满
template<class T>
bool CircularLinkedList<T>::IsFull()const
{
    return false;
}

//表排序——冒泡排序
template<class T>
void CircularLinkedList<T>::Sort()
{
    LinkNode<T> *curNode = first->link;
    while (first != curNode)
    {
        LinkNode<T> *nextNode = curNode->link;
        while (first != nextNode)
        {
            if (curNode->data < nextNode->data)
            {
                T temp = curNode->data;
                curNode->data = nextNode->data;
                nextNode->data = temp;
            }
            nextNode = nextNode->link;
        }
        curNode = curNode->link;
    }
}

//前插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void CircularLinkedList<T>::InputFront(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = NULL;
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cerr << "* 存储分配错误" << endl;
            exit(1);
        }
        if (first->link == first)
        {
            lastNode = newNode;
        }
        newNode->link = first->link;                    //新结点中指针域的指针指向链表的第一个结点
        first->link = newNode;                          //附加头结点中指针域的指针指向新结点
        value = get_value(s_value);
    }
    lastNode->link = first;
}

//后插法建立链表
//endTag是约定的输入序列结束的标志。如果输入序列是正整数，endTag可以是0或负数；
//如果输入序列是字符，endTag可以是字符集中不会出现的字符，如“\0”。
template<class T>
void CircularLinkedList<T>::InputRear(const T& endTag)
{
    MakeEmpty();
    LinkNode<T> *lastNode = first;                      //设置链表的最后一个结点为附加头结点
    string s_value;
    T value = get_value(s_value);
    while (endTag != value)
    {
        LinkNode<T> *newNode = new LinkNode<T>(value);  //创建新结点
        if (NULL == newNode)
        {
            cerr << "* 存储分配错误" << endl;
            exit(1);
        }
        lastNode->link = newNode;                       //最后一个结点中指针域的指针指向新结点
        lastNode = newNode;                             //设置最后一个结点为新结点
        value = get_value(s_value);
    }
    lastNode->link = first;
}

//输出所有结点的数据值
template<class T>
void CircularLinkedList<T>::Output()const
{
    LinkNode<T> *curNode = first->link;
    while (first != curNode)
    {
        cout << "curNode->data = " << curNode->data << endl;
        curNode = curNode->link;
    }
}

//链表逆置
template<class T>
void CircularLinkedList<T>::Reverse()
{
    LinkNode<T> *prevNode = first;
    LinkNode<T> *curNode = first->link;
    LinkNode<T> *nextNode = curNode->link;
    while (first != curNode) 
    {
        curNode->link = prevNode;
        prevNode = curNode;
        curNode = nextNode;
        nextNode = curNode->link;
    }
    first->link = prevNode;
}

//清空链表(保留附加头结点)
template<class T>
void CircularLinkedList<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (first != first->link)        //当链表不为空时，删去链表中所有结点
    {
        curNode = first->link;          //保存被删结点
        first->link = curNode->link;    //将链表附加头结点中指针域的指针指向被删结点的下一个结点
        delete curNode;                 //从链表上摘下被删结点
    }
}

//链表间赋值操作——重载等号运算符
template<class T>
CircularLinkedList<T>& CircularLinkedList<T>::operator=(const CircularLinkedList<T>& L)
{
    cout << "$ 执行赋值操作函数" << endl;
    LinkNode<T> *srcptr = L.GetHead();
    LinkNode<T> *destptr = first = new LinkNode<T>;
    while (L.GetHead() != srcptr->link)
    {
        srcptr = srcptr->link;
        destptr->link = new LinkNode<T>(srcptr->data);
        destptr = destptr->link;
    }
    destptr->link = first;
    return *this;
}

//返回附加头结点的地址
template<class T>
LinkNode<T>* CircularLinkedList<T>::GetHead()const
{
    return first;
}

//返回输入的结点数据值
template <class T>
T CircularLinkedList<T>::get_value(string& s_value)
{
    cout << "newNode->data = ";
    cin >> s_value;
    return StrToTtype(s_value);
}

//判断输入的字符串每个字符是否都是数值0~9
template <class T>
bool CircularLinkedList<T>::IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < ‘0‘) || (s_num[i] > ‘9‘))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T CircularLinkedList<T>::StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}


#endif /* CIRCULAR_LINKED_LIST_H_ */

3.3 main文件

main.cpp


#include "CircularLinkedList.h" //带附加头结点



#define EXIT 0              //退出


#define CONSTRUCT_COPY 1    //拷贝构造链表


#define LENGTH 2            //计算链表的结点总数


#define SEARCH 3            //搜索数据值为x的结点并返回


#define LOCATE 4            //获取第i个结点并返回


#define GETDATA 5           //获取第i个结点的数据值保存至x，并返回获取成功与否


#define SETDATA 6           //修改第i个结点的数据值为x


#define INSERT 7            //在第i个结点后插入数据值为x的新结点


#define REMOVE 8            //删除第i个结点，并将被删结点的数据值保存至x


#define ISEMPTY 9           //判断表是否为空


#define ISFULL 10           //判断表是否为满


#define SORT 11             //表排序——冒泡排序


#define INPUTFRONT 12       //前插法建立链表


#define INPUTREAR 13        //后插法建立链表


#define OUTPUT 14           //输出所有结点的数据值


#define REVERSE 15          //链表逆置


#define MAKEEMPTY 16        //清空链表


#define OPERATOR_COPY 17    //链表间赋值操作——重载等号运算符


#define GETHEAD 18          //返回头结点的地址


void print_description()
{
    cout << "------------------------------>循环链表<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 拷贝构造链表" << endl;
    cout << "#2： 计算链表的结点总数" << endl;
    cout << "#3： 搜索数据值为x的结点并返回" << endl;
    cout << "#4： 获取第i个结点并返回" << endl;
    cout << "#5： 获取第i个结点的数据值保存至x，并返回获取成功与否" << endl;
    cout << "#6： 修改第i个结点的数据值为x" << endl;
    cout << "#7： 在第i个结点后插入数据值为x的新结点" << endl;
    cout << "#8： 删除第i个结点，并将被删结点的数据值保存至x" << endl;
    cout << "#9： 判断表是否为空" << endl;
    cout << "#10：判断表是否为满" << endl;
    cout << "#11：表排序——冒泡排序" << endl;
    cout << "#12：前插法建立链表" << endl;
    cout << "#13：后插法建立链表" << endl;
    cout << "#14：输出所有结点的数据值" << endl;
    cout << "#15：链表逆置" << endl;
    cout << "#16：清空链表" << endl;
    cout << "#17：链表间赋值操作——重载等号运算符" << endl;
    cout << "#18：返回头结点的地址" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//输入结点编号
template <class T>
int get_item()
{
    cout << "> 请输入结点编号，item = ";
    string s_item;
    cin >> s_item;
    while (false == CircularLinkedList<T>::IsNumber(s_item))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_item;
    }
    return atoi(s_item.c_str());
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return CircularLinkedList<T>::StrToTtype(s_data);
}

//输入结束标志位
template <class T>
T get_endtag()
{
    cout << "请输入结束标志值，endTag = ";
    string s_endTag;
    cin >> s_endTag;
    return CircularLinkedList<T>::StrToTtype(s_endTag);
}

//构造单链表
template <class T>
CircularLinkedList<T>* construct_linkedlist()
{
    cout << "\n==> 创建循环链表" << endl;
    CircularLinkedList<T> *linkedList = new CircularLinkedList<T>;
    return linkedList;
}

//析构单链表
template <class T>
void destory_linkedlist(CircularLinkedList<T>* linkedList)
{
    cout << "\n==> 释放循环链表在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete linkedList;
    linkedList = NULL;
}

//拷贝构造链表
template <class T>
void construct_copy(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行拷贝构造链表函数" << endl;
    CircularLinkedList<T> cpy_linkedlist = *linkedList;
    cpy_linkedlist.Output();
}

//计算链表的结点总数
template <class T>
void length(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行计算链表的结点总数函数，Length = " << linkedList->Length() << endl;
}

//搜索数据值为x的结点并返回
template <class T>
void search(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行搜索数据值为x的结点并返回函数" << endl;
    T data = get_data<T>();
    LinkNode<T> *node = linkedList->Search(data);
    if (NULL == node)
    {
        cout << "* 搜索失败" << endl;
        return;
    }
    cout << "* 搜索成功，data = " << node->data << endl;
}   

//获取第i个结点并返回
template <class T>
void locate(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行获取第i个结点并返回函数" << endl;
    int n_item = get_item<T>();
    LinkNode<T> *node = linkedList->Locate(n_item);
    if ((NULL == node) || (linkedList->GetHead() == node))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << node->data << endl;
}

//获取第i个结点的数据值保存至x，并返回获取成功与否
template <class T>
void getdata(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行获取第i个结点的数据值保存至x并返回获取成功与否函数" << endl;
    T data;
    int n_item = get_item<T>();
    if (false == linkedList->GetData(n_item, data))
    {
        cout << "* 获取失败" << endl;
        return;
    }
    cout << "* 获取成功，item = " << n_item << "，data = " << data << endl;
}

//修改第i个结点的数据值为x
template <class T>
void setdata(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行修改第i个结点的数据值为x函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    if (false == linkedList->SetData(n_item, data))
    {
        cout << "* 修改失败" << endl;
        return;
    }
    cout << "* 修改成功，item = " << n_item << "，data = " << data << endl;
}

//在第i个结点后插入数据值为x的新结点
template <class T>
void insert(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行在第i个结点后插入数据值为x的新结点函数" << endl;
    int n_item = get_item<T>();
    T data = get_data<T>();
    if (false == linkedList->Insert(n_item, data))
    {
        cout << "* 插入失败" << endl;
        return;
    }
    cout << "* 插入成功，item+1 = " << n_item+1 << "，data = " << data << endl;
}

//删除第i个结点，并将被删结点的数据值保存至x
template <class T>
void remove(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行删除第i个结点并将被删结点的数据值保存至x函数" << endl;
    T data;
    int n_item = get_item<T>();
    if (false == linkedList->Remove(n_item, data))
    {
        cout << "* 删除失败" << endl;
        return;
    }
    cout << "* 删除成功，item = " << n_item << "，data = " << data << endl;
}

//判断表是否为空
template <class T>
void isempty(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行判断表是否为空函数，IsEmpty = " << linkedList->IsEmpty() << endl;
}

//判断表是否为满
template <class T>
void isfull(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行判断表是否为满函数，IsFull = " << linkedList->IsFull() << endl;
}

//表排序——冒泡排序
template <class T>
void sort(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行表排序——冒泡排序函数" << endl;
    linkedList->Sort();
}

//前插法建立链表
template <class T>
void inputfront(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行前插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    linkedList->InputFront(endTag);
}

//后插法建立链表
template <class T>
void inputrear(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行后插法建立链表函数" << endl;
    T endTag = get_endtag<T>();
    linkedList->InputRear(endTag);
}

//输出所有结点的数据值
template <class T>
void output(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行输出所有结点的数据值函数" << endl; 
    linkedList->Output();
}

//链表逆置
template <class T>
void reverse(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行链表逆置函数" << endl;
    linkedList->Reverse();
}

//清空链表
template <class T>
void make_empty(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行清空链表函数" << endl; 
    linkedList->MakeEmpty();
}

//链表间赋值操作——重载等号运算符
template <class T>
void operator_copy(CircularLinkedList<T>* linkedList)
{
    cout << "$ 执行链表间赋值操作——重载等号运算符函数" << endl; 
    CircularLinkedList<T> cpy_linkedlist;
    cpy_linkedlist = *linkedList;//或cpy_linkedlist.operator=(*linkedList);
    cpy_linkedlist.Output();
}

//返回头结点的地址
template <class T>
void gethead(CircularLinkedList<T>* linkedList)
{       
    LinkNode<T> *head = linkedList->GetHead();
    cout << "$ 执行返回头结点的地址函数，&first = " << &head << endl;
}

//单链表操作选择
template <class T>
void select_operation(CircularLinkedList<T>* linkedList)
{
    if (NULL == linkedList)
    {
        cout << "* 没有构造循环链表，请先构造循环链表。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == CircularLinkedList<T>::IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case CONSTRUCT_COPY://拷贝构造链表
            {
                construct_copy(linkedList);
                break;
            }
            case LENGTH://计算链表的结点总数
            {
                length(linkedList);
                break;
            }
            case SEARCH://搜索数据值为x的结点并返回
            {
                search(linkedList);
                break;
            }
            case LOCATE://获取第i个结点并返回
            {
                locate(linkedList);
                break;
            }
            case GETDATA://获取第i个结点的数据值保存至x，并返回获取成功与否
            {
                getdata(linkedList);
                break;
            }
            case SETDATA://修改第i个结点的数据值为x
            {
                setdata(linkedList);
                break;
            }
            case INSERT://在第i个结点后插入数据值为x的新结点
            {
                insert(linkedList);
                break;
            }
            case REMOVE://删除第i个结点，并将被删结点的数据值保存至x
            {
                remove(linkedList);
                break;
            }
            case ISEMPTY://判断表是否为空
            {
                isempty(linkedList);
                break;
            }
            case ISFULL://判断表是否为满
            {
                isfull(linkedList);
                break;
            }
            case SORT://表排序——冒泡排序
            {
                sort(linkedList);
                break;
            }
            case INPUTFRONT://前插法建立链表
            {
                inputfront(linkedList);
                break;
            }
            case INPUTREAR://后插法建立链表
            {
                inputrear(linkedList);
                break;
            }
            case OUTPUT://输出所有结点的数据值
            {
                output(linkedList);
                break;
            }
            case REVERSE://链表逆置
            {
                reverse(linkedList);
                break;
            }
            case MAKEEMPTY://清空链表
            {
                make_empty(linkedList);
                break;
            }
            case OPERATOR_COPY://链表间赋值操作——重载等号运算符
            {
                operator_copy(linkedList);
                break;
            }
            case GETHEAD://返回头结点的地址
            {
                gethead(linkedList);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    CircularLinkedList<int> *linkedList = construct_linkedlist<int>();
    select_operation(linkedList);
    destory_linkedlist(linkedList);
    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第二章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章
[3]?百度搜索关键字：约瑟夫环

约瑟夫问题的求解——利用循环链表

标签：

原文地址：http://blog.csdn.net/cainv89/article/details/51335494

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行