【数据结构】应用循环链表解决约瑟夫问题（无头节点）

最新推荐文章于 2022-10-17 16:52:47 发布
最新推荐文章于 2022-10-17 16:52:47 发布
阅读量968 收藏 5
点赞数 4
分类专栏： 数据结构与算法 文章标签： 链表 约瑟夫问题 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qizhi666/article/details/118905427
版权

文章目录

什么是约瑟夫问题？

首先我们先看个故事：

据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决。Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。 [1] —来自【百度百科】

声明一个类代表人，因为是单项链表，所以在该类中需要有一个指向下一个节点的指针

/**
 * 创建一个Boy类，表示一个节点
 */
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点，默认null

    public Boy (int no) {
        this.no = no;
    }
    //此处getter和setter方法省略
}

添加元素

  • 1.初始状态下，循环链表只有一个指针，我们声明这个指针为first，因为没有元素，所以这个指针是null

  • 2.第一次添加元素时，假定这个元素是 （1-关羽），那么我们就应该让first指针指向 （1-关羽） 这个元素，因为是循环链表，所以元素 （1-关羽） 的指针（假定定义为next指针）是指向自己的，如下图：
    在这里插入图片描述

  • 3.第二次添加元素时，假定这个元素是 （2-张飞） 需要一下步骤：

    • 第一步：张飞的next指针=关羽的next指针
    • 第二步：关羽的next指针=张飞

在这里插入图片描述

4.第三次在添加元素时，假定这个元素是 （3-赵云） ，那么此时就按照第3步，就ok

总结：添加元素主要分为两部分：1.添加第一元素，自己构成环；2.继续添加元素时，加到环上即可。

/**
 * 创建一个环形的单项链表
 */
class CircleSingleLinkedList{
    //创建一个first节点
    private Boy first;


    /**
     * 添加小孩节点，构建成一格环形的链表
     * @param nums
     */
    public void addBoy(int nums){
        //一、对参数进行校验
        if(nums < 1 ){
            System.out.println("nums的值不正确");
            return;
        }
        //因为first指针不能动，所以定义一个指针，来代替first指针
        Boy curBoy = null;
        //使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            //根据编号,创建小孩节点
            Boy boy = new Boy(i);
            //情况一：当前链表中无元素
            if(i == 1){
                first = boy;
                first.setNext(first);//构建环状
            } else {
            //情况二：当前链表中有元素
                curBoy.setNext(boy);
                boy.setNext(first);
            }
            curBoy = boy;
        }
    }
}

约瑟夫核心问题

因为约瑟夫的人数一共是39+约瑟夫+它的朋友，一共是41个，人数太多画图很复杂，所以以5人为例进行研究。

  • 1.首先准备五个人，寻找一个开始节点 （这里我们就以三国蜀国五虎上将之首关羽作为第一个节点）

在这里插入图片描述

  • 2.因为需要取出元素，而且链表是单向链表，所以必须定义一个辅助变量表示尾指针 （定义为last指针） ，否则无法获取到元素的前一个节点
    ·在这里插入图片描述

  • 3.首先是关羽喊1号，张飞喊2号，然后赵云喊3号，（喊号就是移动last和head指针，只不过，需要移动喊号的次数-1，因为指针本身就在关羽这里） 此时的head指针指向赵云，last指针指向张飞

    • 第一步：赵云出队列
    • 第二步：让张飞的next=赵云的next，即：last.next=head.next;
    • 第三步：继续喊号，即：last指针和head指针继续移动
      在这里插入图片描述

  • 4.依次循环，直到last.next=head.next，此时证明链表中就只有一个元素了，此时就结束了


/**
 * 创建一个环形的单项链表
 */
class CircleSingleLinkedList{
    //创建一个first节点
    private Boy first;


    /**
     * 根据用户的输入，加算出小孩出圈的顺序
     * @param startNo 表示从第几个小孩开始数数
     * @param countNum 表示数几下
     * @param nums 表示初始有多少小孩在权重
     */
    public void countBoy(int startNo , int countNum , int nums){
        //一、参数校验
        if(first == null || startNo < 1 || startNo > nums || countNum > nums){
            System.out.println("参数有误,请重新输入");
            return;
        }
        //定义一个辅助指针last,并辅助赋值,让他指向循环链表的末尾元素
        Boy last = first;
        while (last.getNext() != first){
            last = last.getNext();
        }


        //定义一个临时变量，指向首元素
        Boy head = first;
        //因此此时head是第一个元素，last是最后一个元素，所以只要让这两个元素同时移动，即可保证相对位置是head在前,last元素在其后面
        for (int i = 0; i < startNo-1; i++) {
            head = head.getNext();
            first = first.getNext();

        }


        //遍历要数的次数,直到遍历剩下一个元素为止
        while (head != last){
            for (int i = 0; i < countNum-1 ; i++) {
                head = head.getNext();
                last = last.getNext();
            }
            System.out.println("出队列的人:"+head.getNo());

            //让head元素向后移动
            head = head.getNext();
            last.setNext(head);
        }
        System.out.println("最后剩下的人:"+head.getNo());
    }
}
  • 5.编写一个测试类测试一下：
public class JosepfuDome {
    public static void main(String[] args) {
        //测试添加和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(41);
     	//第一个形参是：从那个元素开始报数
     	//第二个形参是：第几次报数的时候开始出队列
     	//第三本形参是：一共有多少人
        circleSingleLinkedList.countBoy(1,3,41);
    }
}


D:\JAVA\jdk-8u131-windows-x64\bin\java.exe -javaagent:D:\InteIIiJ_IDEA\IntelliJ_IDEA_2019.2.3\lib\idea_rt.jar=57698:D:\InteIIiJ_IDEA\IntelliJ_IDEA_2019.2.3\bin -Dfile.encoding=UTF-8 -classpath D:\JAVA\jdk-8u131-windows-x64\jre\lib\charsets.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\deploy.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\access-bridge-64.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\cldrdata.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\dnsns.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\jaccess.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\jfxrt.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\localedata.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\nashorn.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\sunec.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\sunjce_provider.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\sunmscapi.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\sunpkcs11.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\ext\zipfs.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\javaws.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\jce.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\jfr.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\jfxswt.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\jsse.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\management-agent.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\plugin.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\resources.jar;D:\JAVA\jdk-8u131-windows-x64\jre\lib\rt.jar;G:\java_study\DataStructuresArithmetic\out\production\DataStructuresArithmetic com.atguigu.linkedlist.JosepfuDome
打印出来的孩子是:3
打印出来的孩子是:6
打印出来的孩子是:9
打印出来的孩子是:12
打印出来的孩子是:15
打印出来的孩子是:18
打印出来的孩子是:21
打印出来的孩子是:24
打印出来的孩子是:27
打印出来的孩子是:30
打印出来的孩子是:33
打印出来的孩子是:36
打印出来的孩子是:39
打印出来的孩子是:1
打印出来的孩子是:5
打印出来的孩子是:10
打印出来的孩子是:14
打印出来的孩子是:19
打印出来的孩子是:23
打印出来的孩子是:28
打印出来的孩子是:32
打印出来的孩子是:37
打印出来的孩子是:41
打印出来的孩子是:7
打印出来的孩子是:13
打印出来的孩子是:20
打印出来的孩子是:26
打印出来的孩子是:34
打印出来的孩子是:40
打印出来的孩子是:8
打印出来的孩子是:17
打印出来的孩子是:29
打印出来的孩子是:38
打印出来的孩子是:11
打印出来的孩子是:25
打印出来的孩子是:2
打印出来的孩子是:22
打印出来的孩子是:4
打印出来的孩子是:35
打印出来的孩子是:16
最后留在圈中的小孩是:31

Process finished with exit code 0

我们看到最后的结果的确是：剩下16和31，所以最后站在16和31号的约瑟夫和它的朋友存活了下来。

怎么样？要不要来个可乐庆祝一下，又学废了。。。
在这里插入图片描述

黄金鸡米花
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
用循环链表解约瑟夫问题
愿君出走半生，归来时仍是少年
06-01 2012
原题：用循环链表求解约瑟夫问题，n 个人围成一个圆圈，首先从第 1 个人开始一个一个地顺时针报数，报到第 m 个人，令其出列。然后再从下一个人开始，从 1 顺时针报数，报到第 m 个人，再令其出列，...... ，如此下去，直到圆圈中只剩下一个人为止。此人即为优胜者。 //分析：用不带头结点的循环链表来表达约瑟夫最简单， p 首先指向要报数到的第 1 个人所在的结点， pre 指向 p 所指结点
约瑟夫问题用不含头结点的循环单链表解决
yuki_1209的博客
09-14 966
问题描述： 设有n个人围坐在一个圆桌周围，现从第s个人开始报数，数到第m的人出列，然后从出列的下一个人重新开始报数，数到第m的人又出列，…，如此反复直到所有的人全部出列为止。Josephus问题是：对于任意给定的n,s和m，求出按出列次序得到的n个人员的序列。 现以n=8，s=1，m=4为例，问题的求解过程如图2-15所示。图中s1指向开始报数位置，若初始的顺序为n1，n2，n3，n4，n5，n6，n7，n8。则问题的解为n4，n8，n5，n2，n1，n3，n7，n6。...
java约瑟夫问题链表_JAVA数据结构与算法之链表（四）~ 约瑟夫问题
weixin_33464488的博客
02-27 94
Josephu 问题Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k(1<=k<=n)的人从 1 开始报数，数到m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。解题提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然...
c语言josephus问题循环链表,循环单链表（C语言，无头节点，附约瑟夫杀人问题）...
weixin_35928736的博客
05-21 195
实现以下操作init 初始化traverse 遍历head_add 头追加()，尾追加(尾插法)只需要注释掉函数最后一行的头指针赋值len 长度insert 指定位置插入search 正、反向查找数据，返回第1次匹配的位置，找不到返回-1get 获取指定位置的数据delete 删除指定位置的数据clear 清空链表(注：使用头节点实现更好操作一些)代码#include #include #incl...
C语言循环链表实现约瑟夫环问题
qq_55227591的博客
11-09 2737
问题描述 约瑟夫环问题 （1）问题描述 设有编号为1,2,…,n的n（n＞0）个人围成一个圈，每个人持有一个密码m。从第一个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。 （2）基本要求 建立模型，确定存储结构。 对任意n个人，密码为m，实现约瑟夫环问题。 出圈的顺序可以依次输出，也可以用一个数组存储。 （3）设计思想 首先，设计实现约瑟夫环问题的存储结构。由
使用不带头结点的循环链表实现队列（数据结构）
aoe41606的博客
06-19 972
我使用类模版来完毕循环链表实现队列的操作。首先定义一个结点类node用来保存结点信息，然后定义队列类Queue。接下来我们思考：要完毕队列的4个基本操作即 1.推断队列是否为空 2.在队列尾部push进数据 3.从队列头部取出数据 4.删除掉队列首部的元素 我们这个Queue类须要什么成员变量？ 答案是： （维护）队列尾部结点、队列大小就够了。 我们来分析。尾部pu...
C数据结构循环链表实现约瑟夫环
01-01
C数据结构循环链表实现约瑟夫环 本文代码均在turbo C 2.0 的环境下运行通过，并得到正确结果，本程序为用循环链表实现约瑟夫环，即有m个人站成一个圆环，从某人（队列第一个）开始报数，约定从某数开始的第n个人出列...
Java采用循环链表结构求解约瑟夫问题
09-04
主要介绍了Java采用循环链表结构求解约瑟夫问题的解决方法,是很多Java面试环节都会遇到的经典考题,这里详细给出了约瑟夫问题的原理及Java解决方法,是非常经典的应用实例,具有一定的参考借鉴价值,需要的朋友可以参考...
C语言基于循环链表解决约瑟夫环问题的方法示例
01-20
本文实例讲述了C语言基于循环链表解决约瑟夫环问题的方法。分享给大家供大家参考，具体如下： 概述： 约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（以编号1，2，3，…，n分别表示）围坐在一张圆桌...
c语言循环链表解决约瑟夫问题
01-31
可以运行，课堂作业
565-约瑟夫环问题(无头节点的单向循环链表)
LINZEYU666的博客
09-16 2452
约瑟夫环问题(无头节点的单向循环链表) 我们采用无头节点的单向循环链表解决约瑟夫环问题 假设k=1 , m=3 图中的1个数字代表着1个节点 我们采用双指针，初始化均指向第一个有效节点 因为单链表删除节点，用双指针方便 我们用p专门用来指向要删除的节点 q专门用来指向要删除的节点的前一个节点 但是现在比较尴尬的是，它没有头节点，所以一开始只能指向第一个有效节点 k=1的话，它们本身就在第一个元素上，从第一个元素开始报数，报道第3个， 现在我们要删除3这个节点，3出列。 然后p指向的是4节点，从1开始报
循环链表解决约瑟夫环问题
九月鹰飞
07-29 821
约瑟夫环问题，已知n个人，从编号为k的人开始报数，数到m的那个人出列；他的下一个又从1开始报数， 数到m的那个人又出列，依此重复，直到所有的人出列。思路如下： (1)建立一个具有n个结点、无头结点的循环链表。 (2)确定第一个报数人的位置 (3)不断地从链表中删除结点，直到链表为空。 typedef struct node { int num; struct node *next; }
实参形参与指针5——无头结点循环链表与带头结点循环链表
weixin_42224065的博客
10-17 1739
虽然C语言的指针偏向底层，不利于上手和大型项目开发（某些），但是用C去实现链表基本操作是有利于我们的代码功底的。而且在实现的过程中，实现远比理解要复杂困难的多，尤其是循环链表，当你实现过就会发现，为啥你的大学老师总是劝你要带头结点了。
论约瑟夫问题
lyx32768的专栏
10-19 326
看起来，这是一道朴素的题目。题目不是很难，用一些奇奇怪怪的模拟就可以了。
链表题目详解2 约瑟夫环
TENET_T的博客
09-24 374
约瑟夫环问题 问题描述：编号为1，2，…，n的n个人围成一圈，从第一个人开始报数，报到m的人出圈，剩下的人继续从1开始报数，报到m的人出圈；如此往复，直到所有人出圈，输出出圈的人的序号 约瑟夫环问题（带密码版） 问题描述：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每个人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m 值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直到所有
使用循环单链表解决约瑟夫问题
sinat_31089473的博客
07-30 1362
Josephu问题为：设编号为1，2，...n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 这里用一个不带头结点的循环链表来处理Josephu问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。 以1，2，3，4，
约瑟夫环（2）
Maoriland的博客
10-15 308
约瑟夫环问题可以用一个不带头结点的循环链表解决。请编写算法，先构成一个有n个结点的不带头结点的循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除时算法结束。，n的n个人围坐一圈，约定编号为k（1≤k≤n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此产生一个出队编号的序列。
为什么链表可以没有头结点，不能没有头指针
枯树无花
02-04 5545
如果有头结点的话，头指针必然指向头结点。 头结点是用来存储诸如链表长度之类的信息的，可有可无，而头指针是指向这个链表的地址的关键指针，如果没有它，这个链表就找不到，相当于没创建一样。 另外这篇文章写得也很详细，转自：http://blog.csdn.net/zhenyusoso/article/details/6092843...
约瑟夫环问题研究(一)
糊一笑
10-25 559
最近在看C方面的东西，看到了李明老师讲解的约瑟夫环问题，
数据结构用循环链表实现约瑟夫环
最新发布
12-07
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成一个环。使用循环链表可以很方便地实现约瑟夫环问题。 具体实现步骤如下： 1. 定义一个节点结构体，包含一个数据域和一个指向下一个节点的指针域。 2. 构建循环链表，将每个节点连接起来形成一个环。 3. 定义一个计数器，从指定位置开始遍历链表，每遍历到一个节点就将计数器加1，当计数器的值等于指定的数n时，将该节点从链表中删除。 4. 重复步骤3，直到链表中只剩下一个节点为止。 下面是一个C语言实现的例子： ```c #include <stdio.h> #include <stdlib.h> // 定义节点结构体 typedef struct node { int data; struct node *next; } Node; // 构建循环链表 Node *buildList(int n) { Node *head = NULL, *tail = NULL; for (int i = 1; i <= n; i++) { Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = i; newNode->next = NULL; if (head == NULL) { head = newNode; tail = newNode; } else { tail->next = newNode; tail = newNode; } } tail->next = head; // 将最后一个节点指向头节点，形成循环链表 return head; } // 删除节点 Node *deleteNode(Node *head, int n, int m) { Node *p = head, *pre = NULL; int count = 0; while (p->next != p) { // 当链表中只剩下一个节点时结束循环 count++; if (count == m) { // 找到要删除的节点 printf("%d ", p->data); // 输出该节点的值 pre->next = p->next; // 将该节点从链表中删除 Node *temp = p; p = p->next; free(temp); count = 0; } else { pre = p; p = p->next; } } printf("%d\n", p->data); // 输出最后剩下的节点的值 free(p); return NULL; } int main() { int n, m; printf("请输入总人数n和报数m："); scanf("%d %d", &n, &m); Node *head = buildList(n); printf("出列顺序为："); head = deleteNode(head, n, m); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值