【009】数据结构：线性表之链式存储结构——C++循环链表和约瑟夫（Josephu）问题的代码实现

循环链表：

• 链表的最后一个节点的next不指向空，指向头结点（或第一个有效节点）。

判断是否遍历到最后一个节点的方式：

• 判断next是不是等于头结点
• 判断是否遍历到size()

判断是否是循环链表的方式：

• 令size=n*size()，判断链表是否能遍历n遍

插入数据原理：

1. 创建新的节点
2. 使用循环指针变量找到需要插入节点的位置
3. 插入节点：
   newnode->next = pCurrent->next;
   pCurrent->next = newnode;
4. 更改size：size++

约瑟夫问题：

• n个人围成一个圆圈，编号分别为1~n；
• 第一个人开始从1开始顺时针报数，报到第m个人，令其出列；
• 再从下一个人开始从1顺时针报数，报到第m个人，再令其出列，…，如此循环；
• 求出列顺序。

实现方法：

• 使用循环链表模拟n个人围成的圆圈
• 采用循环链表的查找及删除、打印方法解决该问题

C++约瑟夫问题的代码实现

注： 使用和单向链表不同的方式（企业链表）实现

main.cpp

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

struct MyNum
{
    CircleLinkNode node;
    int num;
};

//自定义打印函数
void print(CircleLinkNode *data);
//自定义数据比较函数
bool compare(CircleLinkNode *data1, CircleLinkNode *data2);

int main()
{
    //获取m,n数据
    int m, n;
    std::cout << "Please enter the n, m:";
    std::cin >> n >> m;

    //创建循环链表
    CircleLinkList list;
    MyNum *person = new MyNum[n];
    for (int i = 0; i < n; i++)
    {
        person[i].num = i + 1;
        list.insert((CircleLinkNode *)&person[i], i);
    }
    list.show(print);

    int index = 1;
    CircleLinkNode *pCurrent = list.front();

    while (list.getSize() > 1)
    {
        //判断是否报数到m
        if (index == m)
        {
            //输出出列的序号
            print(pCurrent);
            //缓存待删除节点的下一个节点
            CircleLinkNode *pNext = pCurrent->next;
            //删除节点
            list.RemoveByData(pCurrent, compare);
            pCurrent = pNext;
            //判断是否指向头结点
            if (pCurrent == list.getHead())
                pCurrent = pCurrent->next;
            //重置Index
            index = 1;
        }
        index++;
        pCurrent = pCurrent->next;
        if (pCurrent == list.getHead())
            pCurrent = pCurrent->next;
    }

    //判断是否执行到最后一个
    if(list.getSize()==1)
        std::cout << "The last one is: " << ((MyNum *)list.front())->num << std::endl;
    else
        std::cerr << "ERROR!" << std::endl;

    delete[] person;
    return 0;
}

//自定义打印函数
void print(CircleLinkNode *data)
{
    MyNum *p = (MyNum *)data;
    std::cout << p->num << "    ";
}

//自定义数据比较函数
bool compare(CircleLinkNode *data1, CircleLinkNode *data2)
{
    MyNum *p1 = (MyNum *)data1;
    MyNum *p2 = (MyNum *)data2;
    if (p1->num == p2->num)
        return true;
    return false;
}

CircleLinkList.h

#ifndef CIRCLE_LINKLIST_H
#define CIRCLE_LINKLIST_H

#include <iostream>

//节点的定义
class CircleLinkNode
{
public:
    CircleLinkNode *next;
};

//用户定义的数据比较函数声明(回调函数)
typedef bool (*CompareNode)(CircleLinkNode *, CircleLinkNode *);
//用户定义的打印函数(回调函数)
typedef void (*ShowNode)(CircleLinkNode *);

class CircleLinkList
{
private:
    CircleLinkNode head;
    int size;

public:
    CircleLinkList();
    ~CircleLinkList();

    //插入函数
    void insert(CircleLinkNode *data, int pos);
    //获得头节点
    CircleLinkNode *getHead();
    //获得第一个元素
    CircleLinkNode *front();
    //根据位置删除
    void RemoveByPos(int pos);
    //根据数据删除
    //将比较交给用户，只使用回调函数调用结果
    void RemoveByData(CircleLinkNode *data, CompareNode compare);
    //获得链表的长度
    int getSize();
    //判断是否为空
    bool isEmpty();
    //查找(根据值)
    int find(CircleLinkNode *data, CompareNode compare);
    //打印节点
    void show(ShowNode print);
};

#endif

CircleLinkList.cpp

#include "CircleLinkList.h"

CircleLinkList::CircleLinkList()
{
    //循环链表的初始化
    head.next = &head;
    size = 0;
}
CircleLinkList::~CircleLinkList()
{
}

//插入函数
void CircleLinkList::CircleLinkList::insert(CircleLinkNode *data, int pos)
{
    if (data == NULL)
    {
        std::cerr << "ERROR: The data is empty!" << std::endl;
        return;
    }
    //友好处理
    if (pos < 0 || pos > size)
        pos = size;

    //根据位置查找节点
    //辅助指针变量
    CircleLinkNode *pCurrent = &head;
    for (int i = 0; i < pos; i++)
        pCurrent = pCurrent->next;

    //新数据入链表
    data->next = pCurrent->next;
    pCurrent->next = data;
    size++;
}

//获得头节点
CircleLinkNode *CircleLinkList::getHead()
{
    return &head;
}

//获得第一个元素
CircleLinkNode *CircleLinkList::front()
{
    return head.next;
}

//根据位置删除
void CircleLinkList::RemoveByPos(int pos)
{
    if (pos < 0 || pos >= size)
    {
        std::cerr << "ERROR: The pos is out of bounds!" << std::endl;
        return;
    }

    //根据pos找节点
    //辅助指针变量
    CircleLinkNode *pCurrent = &head;
    for (int i = 0; i < pos; i++)
        pCurrent = pCurrent->next;

    //删除数据
    pCurrent->next = pCurrent->next->next;
    size--;
}

//根据数据删除(只删除查找到的第一个数据)
//将比较交给用户，只使用回调函数调用结果
void CircleLinkList::RemoveByData(CircleLinkNode *data, CompareNode compare)
{
    if (data == NULL)
    {
        std::cerr << "ERROR: The data is empty!" << std::endl;
        return;
    }
    //维护一个bool值，查看链表中是否存在与data相同的值
    bool isRemove = false;

    //这个是循环链表
    //辅助指针：被删除节点的上一个节点
    CircleLinkNode *pPrev = &head;
    //辅助指针：被删除节点（查找与data相同的节点）
    CircleLinkNode *pCurrent = pPrev->next;

    for (int i = 0; i < size; i++)
    {
        if (compare(pCurrent, data) == true)
        {
            //删除节点
            pPrev->next = pCurrent->next;
            isRemove = true;
            size--;
            break;
        }
        //两个指针同时向后移动
        pPrev = pCurrent;
        pCurrent = pPrev->next;
    }
    //判断data是否有效
    if (isRemove == false)
        std::cerr << "ERROR: The data is invalid!" << std::endl;
}

//获得链表的长度
int CircleLinkList::getSize()
{
    return size;
}

//判断是否为空
bool CircleLinkList::isEmpty()
{
    if (size == 0)
        return true;
    return false;
}

//查找(根据值)
int CircleLinkList::find(CircleLinkNode *data, CompareNode compare)
{
    if (data == NULL)
    {
        std::cerr << "ERROR: The data is empty!" << std::endl;
        exit(EXIT_FAILURE);
    }

    //这个是循环链表
    CircleLinkNode *pCurrent = head.next;
    for (int i = 0; i < size; i++)
    {
        if (compare(pCurrent, data) == true)
            return i;
        pCurrent = pCurrent->next;
    }

    //若不存在compare(pCurrent, data) == true，提示错误信息并返回-1
    std::cout << "ERROR: The data is invalid!" << std::endl;
    return -1;
}

//打印节点
void CircleLinkList::show(ShowNode print)
{
    if (size == 0)
    {
        std::cerr << "ERROR: The list is empty!" << std::endl;
        return;
    }
    //辅助指针变量
    CircleLinkNode *pCurrent = head.next;
    for (int i = 0; i < size; i++)
    {
        print(pCurrent);
        pCurrent = pCurrent->next;
    }
    std::cout << std::endl << "-------------------------------------------" << std::endl;
}