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

最新推荐文章于 2023-03-25 12:41:42 发布
最新推荐文章于 2023-03-25 12:41:42 发布
阅读量8.6k 收藏 17
点赞数 5
分类专栏： C++数据结构 文章标签： 数据结构 约瑟夫问题 约瑟夫环 约瑟夫问题的算法原理 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/51335494
版权

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

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 循环链表的类定义及其操作的实现(带附加头结点)

  • 文件：CircLinkedList.h

    
#ifndef CIRC_LINKED_LIST_H_


#define CIRC_LINKED_LIST_H_



#include "LinkNode.h"


template <class T>
class CircLinkedList//带附加头结点
{
public:
    CircLinkedList();                               //构造函数
    ~CircLinkedList();                              //析构函数
public:
    LinkNode<T>* Locate(int i)const;                    //获取第i个结点并返回
    bool Insert(int i, const T& x);                     //在第i个结点后插入数据值为x的新结点
    LinkNode<T>* Remove(LinkNode<T>* preNode, T& x);    //删除结点，并将被删结点的数据值保存至x，最后返回被删结点的下一个结点
    void MakeEmpty();                                   //清空链表  
public:
    LinkNode<T>* GetHead()const;                //返回附加头结点的地址
private:
    LinkNode<T> *first; //链表的头结点
};

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

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

//获取第i个结点并返回
template<class T>
LinkNode<T>* CircLinkedList<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 CircLinkedList<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;
}

//删除结点，并将被删结点的数据值保存至x，最后返回被删结点的下一个结点
template<class T>
LinkNode<T>* CircLinkedList<T>::Remove(LinkNode<T>* preNode, T& x)
{
    if (NULL == preNode)
    {
        return NULL;
    }
    LinkNode<T> *delNode = preNode->link;
    if (first == delNode)
    {
        delNode = first->link;
        first->link = delNode->link;
    }
    else
    {
        preNode->link = delNode->link;
    }
    x = delNode->data;
    LinkNode<T> *nextNode = delNode->link;
    delete delNode;
    return nextNode;
}

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

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


#endif /* CIRC_LINKED_LIST_H_ */
3.3 求解约瑟夫环的算法实现

  • 文件：Josephus.h

        #ifndef JOSEPHUS_H_
    #define JOSEPHUS_H_

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

    template <class T>
    T Josephus(CircLinkedList<T>* Js, const int n, const int k, const int m)
    {
        T data;
        LinkNode<T> *preNode = NULL;
        LinkNode<T> *curNode = Js->Locate(k);
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 1; j < m; j++)
            {
                if (Js->GetHead() == curNode)
                {
                    curNode = curNode->link;
                }
                preNode = curNode;
                curNode = curNode->link;
            }   
            curNode = Js->Remove(preNode, data);
            cout << "out-" << data << endl;
        }
        LinkNode<T> *solutionNode = Js->GetHead()->link;
        return solutionNode->data;
    }

    #endif /* JOSEPHUS_H_ */
    ```

#### **3.4 主函数(main函数)的实现**

- **文件：main.cpp**
    ```ruby：

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


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

//输入参数
int get_parameter(const string& parameter_name)
{
    cout << parameter_name;
    string s_item;
    cin >> s_item;
    while (false == IsNumber(s_item))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_item;
    }
    return atoi(s_item.c_str());
}

//构造约瑟夫环
template <class T>
CircLinkedList<T>* construct_josephus()
{
    cout << "==> 创建约瑟夫环" << endl;
    CircLinkedList<T> *cirlinkedList = new CircLinkedList<T>;
    return cirlinkedList;
}

//析构约瑟夫环
template <class T>
void destory_josephus(CircLinkedList<T>* cirlinkedList)
{
    cout << "==> 释放约瑟夫环在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete cirlinkedList;
    cirlinkedList = NULL;
}

int main(int argc, char* argv[])
{
    int n = get_parameter("> 请输入总人数，n = ");
    int k = get_parameter("> 请输入开始报数的编号，k = ");
    int m = get_parameter("> 请输入报数间隔，m = ");
    CircLinkedList<int> *cirlinkedList = construct_josephus<int>();
    for (int i = 0; i < n; i++)
    {
        cirlinkedList->Insert(i, i+1);
    }
    int left = Josephus<int>(cirlinkedList, n, k, m);
    cout << "约瑟夫环的解，solution = " << left << endl;
    destory_josephus(cirlinkedList);
    system("pause");
    return 0;
}

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

Cainv89
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
约瑟夫（Josephus）问题——通过循环链表解决
鹿谷門実的博客
09-28 591
1、问题描述 **设编号为1，2，……，n（n>0）的n 个人按顺时针方向围坐一个圆圈，从第1 个人开始顺时针方向自1起顺序报数，报数到 m 为止，报数为 m 的人出列，然后从他的下一个人开始重新报数，报数为 m 的人又出列，……，直到所有的人全部出列为止。设计算法求n个人出圈的次序。 2、基本要求 （1）采用不带头结点的循环链表作为存储结构。 （2）对任意n个人，密码m，实现约瑟夫问题。 ...
用循环单链表解决约瑟夫（Joseph）问题
bwqiang的博客
03-14 1128
@用循环单链表解决约瑟夫（Joseph）问题 用循环单链表解决约瑟夫（Joseph）问题 问题描述 据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所...
约瑟夫环问题图形界面展示
09-27
用图形界面诠释约瑟夫环问题，在vc++6.0环境下进行开发。
数据结构学习-循环链表：处理约瑟夫环问题
G0208的博客
10-11 4169
该问题的难点就在于元素的访问是采取“接力棒”的方式进行访问，需要对循环链表有足够的的理解，同时对密码的处理上也需要小心。对于本次实验来说，还有许多能改进的地方，比如非空链表的检测，可以把它包装成一个函数，这样处理的话，代码会更简洁并且更容易阅读。如有错误，欢迎在评论区指正。以上内容若涉及侵权请联系作者进行删改。
约瑟夫问题_公式原理详解
热门推荐
小黯
04-14 3万+
每次增加一个人，我们第一轮的报数被指定的必定是新加入的人。
可视化讲解：什么是约瑟夫环？
多米学算法的博客
10-26 2760
前言 概念介绍 1. 基本概念 约瑟夫问题，有时也称为约瑟夫斯置换，是一个计算机科学和数学中的问题。在计算机编程算法中，类似问题被称为约瑟夫环，又称丢手绢问题。 2. 问题来历 据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀.
循环链表解决约瑟夫环问题
liu_shi_的博客
03-25 3432
循环链表解决约瑟夫环问题
【算法】约瑟夫环原理及其公式
Elephant_King的博客
11-16 7372
问题描述：将n个人围成一个圈，从1开始依次数数，数到k或者k的倍数时，这个人出局，如此循环直到环中只剩一个人的时候这个人获胜 可以把这个圈想想成一条直线，假设一开始有11人，k=3 将这11个人从1到11进行编号 从1开始报数，此时的人数是11 第一个被淘汰出局的是3 注意，这里淘汰到三继续往后数的话，就相当于4是第一个人，再从1开始计数，此时的人数为10 数次循环往复，相当于每减少一个人，数组整体向后移动k位（此处k=3，所以是移动三位），整体移动，说明最后获胜的人也是向后移动..
算法科普：什么是约瑟夫环
程序员吴师兄的博客
04-20 9342
1 问题描述 约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知 n 个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为 k 的人开始报数，数到 m 的那个人...
约瑟夫环问题-循环链表.cpp
05-01
约瑟夫(Josephus)环问题: 设有n个人围成一圈，现从第s个人开始，拨顺时针方向从1开始报数，数到d的人退出圆圈，然后从退出圆圈的下一个人重新开始报数，数到d的人又退出...试将Josephus问题的求解过程用链表结构实现。
顺序链表，单链表，静态链表求解的约瑟夫问题josephus的C语言代码，可以直接运行
03-16
用顺序链表，单链表，静态链表三种结构求解的约瑟夫josephus问题，完整的代码，可以直接编译，运行的，
java使用链表实现约瑟夫环
08-26
主要为大家详细介绍了java使用链表实现约瑟夫环，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
约瑟夫（Josephus）环问题
03-18
2、 约瑟夫（Josephus）环问题：编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。报m...
三种结构求解约瑟夫问题1
06-06
三种不同方法求解约瑟夫问题。静态链表结构存储的josephus；链表结构存储的josephus；顺序结构存储的josephus
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
循环链表———约瑟夫问题（C语言）
qq_44236958的博客
04-02 759
约瑟夫问题是循环链表的一个典型应用，其描述如下： m个人围成了一圈，从其中任一个人开始，按顺时针顺序 使所有人依次从1开始报数，报到n的人出列；然后使n之后的 人接着从1开始报数，再次使报到n的人出列……如此下去， 求算出列的顺序，及最后留下来的人的编号 将m与n设定为具体数字，使m=8,n=3模拟约瑟夫问题。 以下是关于此函数的完整代码 #include<stdio.h> #inc...
循环链表解决约瑟夫问题
Mekeater的博客
04-03 3172
循环链表解决约瑟夫问题 前言 传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，从而逃过了这场死亡游戏 。 一、循环链表 循环链表，顾名思义
约瑟夫环代码展示，以及理解约瑟夫环
qq_40702349的博客
05-07 1807
本人也是刚刚接触算法，如果有不准确的地方，欢迎大家留言评论，一起学习，一起进步，奥利给！ 约瑟夫环的简单的图例（画的太抽象，大家理解下，我有必要去学学画画了！） 约瑟夫环的原理 1、一群人围在一起坐成环状（如：N） 2、从某个编号开始报数（如：K） 3、数到某个数（如：M）的时候，此人出列， 4、一直循环，直到所有人出列 不够清晰的话，可以看我上边优秀的画图，一群人N指的就...
约瑟夫环问题（c语言实现）
ALWAYS LEARNING
12-21 1万+
约瑟夫环问题问题描述算法1. 非递归法算法理解程序2. 递归法程序3. 循环双链表思路程序 问题描述 有N个人，编号为 1～n，围成一个圈，编号1的人手上有一个热狗开始向下一个人传递，在热狗传递 m 次后，此时拿着热狗的人退出，剩余的人围成一个圈，从退出的人的下一位再开始上述循环，知道最后一个留下来的人胜利。 如果n为5，m为1，则退出的人编号依次为2，4，1，5，最后胜利的是3。 算法 1. 非...
java约瑟夫问题循环链表
最新发布
12-28
循环链表是解决约瑟夫问题的一种常见方法。下面是一个使用Java循环链表解决约瑟夫问题的示例： ```java class Node { int data; Node next; public Node(int data) { this.data = data; } } class CircularLinkedList { private Node head; private Node tail; public void add(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; tail = newNode; tail.next = head; } else { tail.next = newNode; tail = newNode; tail.next = head; } } public void remove(Node node) { if (head == null) { return; } if (head == node) { head = head.next; tail.next = head; } else { Node current = head; while (current.next != node) { current = current.next; } current.next = node.next; if (node == tail) { tail = current; tail.next = head; } } } public void josephus(int k) { Node current = head; while (current.next != current) { for (int i = 1; i < k; i++) { current = current.next; } System.out.print(current.data + " "); remove(current); current = current.next; } System.out.println(current.data); } } public class Main { public static void main(String[] args) { CircularLinkedList list = new CircularLinkedList(); int n = 7; // 总人数 int k = 3; // 报数为3的人出列 for (int i = 1; i <= n; i++) { list.add(i); } System.out.println("出列顺序："); list.josephus(k); } } ``` 这段代码中，我们首先定义了一个`Node`类来表示循环链表的节点，然后定义了`CircularLinkedList`类来实现循环链表的操作。在`josephus`方法中，我们使用循环链表模拟约瑟夫问题的解决过程，每次找到第k个节点并移除，直到只剩下一个节点为止。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值