约瑟夫环？简简单单！!（java）

最新推荐文章于 2022-12-19 13:23:13 发布
最新推荐文章于 2022-12-19 13:23:13 发布
阅读量343 收藏 2
点赞数
分类专栏： java数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45876091/article/details/118732225
版权

链表 队列 数据结构 java 算法

Java解决约瑟夫环问题


约瑟夫问题：
场景：
一堆猴子都有编号，编号是1，2，3 …m，这群猴子（m个）按照1-m的顺序围坐一圈，
从第1开始数，每数到第N个，该猴子就要离开此圈，这样依次下来，
直到圈中只剩下最后一只猴子，则该猴子为大王。
解决方法：单向环形链表或数组(取模,就像环形队列),下面解决的方法为单向环形链表
解决思路：
用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
本文代码流程：

  • 定义描述约瑟夫环节点的类,该节点中包含节点的data域：索引no,该节点的next域：next
  • 定义解决约瑟夫环问题的类,该类中定义约瑟夫环的首节点first,类中有创建约瑟夫环方法,打印约瑟夫环方法,约瑟夫环出圈顺序方法
  • 创建约瑟夫环方法:参数是约瑟夫环节点个数num,方法中curr为临时节点,表示为当前所在节点
  • 出圈方法：参数是游戏开始索引startIndex,一轮游戏经过的人数k,约瑟夫环的节点个数num,
    • 首先创建约瑟夫环
    • 定位到游戏指定的开始节点
    • 开始循环出圈
    • 获得出圈顺序数组outQueue

1.描述约瑟夫环节点的类

/*约瑟夫环节点*/
class JRPNode{
    /*no(索引)*/
    private int no;
    /*next*/
    private JRPNode next;

    public JRPNode() {
    }

    public JRPNode(int no) {
        this.no = no;
    }

    public JRPNode( int no, JRPNode next) {
        this.no = no;
        this.next = next;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public JRPNode getNext() {
        return next;
    }

    public void setNext(JRPNode next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "JRPNode{" +
                "no=" + no +
                '}';
    }
}

2.解决约瑟夫环问题的类

public class JosephRingProblem{
    /*创建的第一个节点*/
    private static JRPNode first=null;

3.创建约瑟夫环

  /**
     * 方法描述
     * @param: [num]
     * @return: void
     * @author: zh
     * @date: 2021/7/14
     * 创建约瑟夫环(指定节点个数)
    */
    public static void addNode(int num){
        if (num<1){
            System.out.println("无法创建约瑟夫环！");
            return;
        }
        /*记录当前节点*/
        JRPNode curr=new JRPNode();
        for (int i = 1; i <= num; i++) {

            JRPNode node=new JRPNode(i) ;
            /*当是第一个节点时,需要自己连自己形成一个环状*/
            if (i==1){
                /*初始化首节点*/
                first=node;
                /*因为只有首节点,所以将首节点的next域指向首节点形成环装*/
                first.setNext(first);
                /*设置当前节点为首节点*/
                curr=first;
            }else {
                /*由于第一次当前的节点指向first节点,即就是从first->first ---->first->node first(即断了环)*/
                curr.setNext(node);
                /*设置当前节点为新添加的节点*/
                curr=node;
                /*当前节点最终指向首节点,形成环first->node->first*/
                curr.setNext(first);
            }

        }
    }

4.实现约瑟夫环出圈

 /**
    * 方法描述
    * @param: [startIndex, k, num]
    * @return: int
    * @author: zh
    * @date: 2021/7/14
    * 约瑟夫环出圈(开始索引,一轮经过节点的个数,约瑟夫环节点的个数)
   */
    public  int[] outCircle(int startIndex, int k,int num){
        if (k<1){
        System.out.println("k值有问题！");
        return null;
        }
        addNode(num);
        JosephRingProblem.list();
        JRPNode curr=first;
        /*得到游戏开始的节点*/
        while (curr.getNo() != startIndex) {
            curr = curr.getNext();
        }
        /*定义一个数组存储出圈的顺序*/
        int[] outQueue=new int[num];
    for (int i1 = 0; i1 < num; i1++) {
        /*每一次内循环都会得到出圈人之前的那个节点,因为这样更容易删除出圈节点,所以内循环是k-1次*/
        for (int i = 0; i < k-1; i++) {
            curr=curr.getNext();
        }
        /*出圈的编号*/
        outQueue[i1]= curr.getNext().getNo();
        if (i1==num-1){
            System.out.println("最后胜利的是编号为"+outQueue[i1]+"的人");
        }else {
            System.out.println("编号为"+ outQueue[i1]+"的人出圈");
        }
        /*重新连成环*/
        curr.setNext(curr.getNext().getNext());

    }
        return outQueue;
    }

5.打印约瑟夫环

 /**
     * 方法描述
     * @param: []
     * @return: void
     * @author: zh
     * @date: 2021/7/14
     * 打印约瑟夫环
    */
    public static void list(){
        if (first==null){
            System.out.println("约瑟夫环为空");
        }
        JRPNode curr=first;
        while (true) {
            System.out.println(curr);
            if (curr.getNext()==first){
                break;
            }
            curr=curr.getNext();

        }
    }

6.测试主方法

public static void main(String[] args) {
        JosephRingProblem josephRingProblem = new JosephRingProblem();
        int[] outQueue = josephRingProblem.outCircle(7,4,7);
      System.out.println(Arrays.toString(outQueue));
  }

7.完整代码

package LinkedList;

import java.util.Arrays;

/**
 * @author zou
 * @ClassName : PACKAGE_NAME.约瑟夫环问题
 * @Description : 类描述
 * Created by user on 2021-07-14 14:35:43
 * Copyright  2020 user. All rights reserved.
 * 约瑟夫问题：
 * 场景：
 * 一堆猴子都有编号，编号是1，2，3 ...m，这群猴子（m个）按照1-m的顺序围坐一圈，
 * 从第1开始数，每数到第N个，该猴子就要离开此圈，这样依次下来，
 * 直到圈中只剩下最后一只猴子，则该猴子为大王。
 * 解决方法：单向环形链表或数组(取模,就像环形队列)
 */

public class JosephRingProblem{
    /*创建第一个节点*/
    private static JRPNode first=null;
    /**
     * 方法描述
     * @param: [num]
     * @return: void
     * @author: zh
     * @date: 2021/7/14
     * 创建约瑟夫环(指定节点个数)
    */
    public static void addNode(int num){
        if (num<1){
            System.out.println("无法创建约瑟夫环！");
            return;
        }
        /*记录当前节点*/
        JRPNode curr=new JRPNode();
        for (int i = 1; i <= num; i++) {

            JRPNode node=new JRPNode(i) ;
            /*当是第一个节点时,需要自己连自己形成一个环状*/
            if (i==1){
                /*初始化首节点*/
                first=node;
                /*因为只有首节点,所以将首节点的next域指向首节点形成环装*/
                first.setNext(first);
                /*设置当前节点为首节点*/
                curr=first;
            }else {
                /*由于第一次当前的节点指向first节点,即就是从first->first ---->first->node first(即断了环)*/
                curr.setNext(node);
                /*设置当前节点为新添加的节点*/
                curr=node;
                /*当前节点最终指向首节点,形成环first->node->first*/
                curr.setNext(first);
            }

        }
    }
   /**
    * 方法描述
    * @param: [startIndex, k, num]
    * @return: int
    * @author: zh
    * @date: 2021/7/14
    * 约瑟夫环出圈(开始索引,一轮经过节点的个数,约瑟夫环节点的个数)
   */
    public  int[] outCircle(int startIndex, int k,int num){
        if (k<1){
        System.out.println("k值有问题！");
        return null;
        }
        addNode(num);
        JosephRingProblem.list();
        JRPNode curr=first;
        /*得到游戏开始的节点*/
        while (curr.getNo() != startIndex) {
            curr = curr.getNext();
        }
        /*定义一个数组存储出圈的顺序*/
        int[] outQueue=new int[num];
    for (int i1 = 0; i1 < num; i1++) {
        /*每一次内循环都会得到出圈人之前的那个节点,因为这样更容易删除出圈节点,所以内循环是k-1次*/
        for (int i = 0; i < k-1; i++) {
            curr=curr.getNext();
        }
        /*出圈的编号*/
        outQueue[i1]= curr.getNext().getNo();
        if (i1==num-1){
            System.out.println("最后胜利的是编号为"+outQueue[i1]+"的人");
        }else {
            System.out.println("编号为"+ outQueue[i1]+"的人出圈");
        }
        /*重新连成环*/
        curr.setNext(curr.getNext().getNext());

    }
        return outQueue;
    }
    /**
     * 方法描述
     * @param: []
     * @return: void
     * @author: zh
     * @date: 2021/7/14
     * 打印约瑟夫环
    */
    public static void list(){
        if (first==null){
            System.out.println("约瑟夫环为空");
        }
        JRPNode curr=first;
        while (true) {
            System.out.println(curr);
            if (curr.getNext()==first){
                break;
            }
            curr=curr.getNext();

        }
    }


    public static void main(String[] args) {
        JosephRingProblem josephRingProblem = new JosephRingProblem();
        int[] outQueue = josephRingProblem.outCircle(7,4,7);
      System.out.println(Arrays.toString(outQueue));
  }
}
/*约瑟夫环节点*/
class JRPNode{
    /*no(索引)*/
    private int no;
    /*next*/
    private JRPNode next;

    public JRPNode() {
    }

    public JRPNode(int no) {
        this.no = no;
    }

    public JRPNode( int no, JRPNode next) {
        this.no = no;
        this.next = next;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public JRPNode getNext() {
        return next;
    }

    public void setNext(JRPNode next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "JRPNode{" +
                "no=" + no +
                '}';
    }
}
少季池鱼
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
约瑟夫环，java
01-02
这是一个java的约瑟夫问题代码，实现约瑟夫问题（循环链表）！
Java简单实现约瑟夫环算法示例
08-29
Java 简单实现约瑟夫环算法示例 约瑟夫环算法是计算机科学中一个经典的问题，它是由约瑟夫·弗拉维ウス（Flavius Josephus）提出的，他是一名罗马历史学家。该问题的描述是：有 n 人围成一个圆圈，第一个人开始报数...
约瑟夫环数组java实现_Java简单实现约瑟夫环算法示例
weixin_39559750的博客
12-31 246
本文实例讲述了Java简单实现约瑟夫环算法。分享给大家供大家参考，具体如下：1.算法背景:罗马人攻占了乔塔帕特，41人藏在一个山洞中躲过了这场浩劫。这41个人中，包括历史学家josephus和他的一个朋友。剩余的39个人为了表示不向罗马人屈服，决定集体自杀。大家决定了一个自杀方案，所有这41人围城一个圆圈，由第一个人开始顺时针报数，没报数为3的人就立刻自杀，然后由下一个人重新开始报数仍然是每报数为...
约瑟夫环(Java)
Monkey-yc
07-20 240
大名鼎鼎的约瑟夫环： 约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为1的人开始报数，数到m的那个人被杀；他的下一个人又从1开始报数，数到m的那个人又被杀；依此规律重复下去，直到圆桌周围只剩下最后一个幸存者。 这是一个循环链表问题。每次杀人就将该节点删除，然后继续报数即可。 生成链表用的是尾插法，然后让最后一个节点指向第一...
Josephu(约瑟夫、约瑟夫环) 问题
小白鼠丶
08-19 918
示意图 思路分析 代码实现 package com.liuq.linkedlist; /** * Tips: * * @author Liuq * @version 2019年08月08日 */ public class Josepfu { public static void main(String[] args) { // ...
Java约瑟夫环(环链)
qq_51682771的博客
06-30 356
N个人围成一圈，从第M个开始报数，第K个将被杀掉。例如M=1，N=6，K=5 被杀掉的顺序是：546231使用循环单链表模拟，主要一个问题就是当k=1时找第一个节点的前一个节点，法一是找一个，另外就是一次寻找，我用的后面那种。...
java 实现约瑟夫环的实例代码
09-04
这个Java实现有效地运用了链表数据结构来解决约瑟夫环问题，展示了如何用面向对象的方式构造和操作数据结构。通过这种方式，我们不仅可以理解约瑟夫环的算法逻辑，还能学习到Java中链表的创建、遍历和修改等基本操作...
yuesefuhuan.rar_约瑟夫环 java
09-24
《约瑟夫环 Java 实现详解》 约瑟夫环，又称为约瑟夫问题，是一个著名的理论问题，源自古罗马历史的一个传说。在数学和计算机科学领域，它被用来探讨循环移位的问题。约瑟夫环问题的基本设定是：有一群人围成一个圈...
java使用链表实现约瑟夫环
08-26
Java 使用链表实现约瑟夫环 约瑟夫环是一个经典的数学应用问题，它描述了n个人围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去...
Java约瑟夫环演示Applet源码
06-07
Java约瑟夫环（Josephus Problem）是一种经典的理论问题，源于古罗马的一种传说。在编程领域，它通常被用来展示循环、链表操作以及算法设计。在这个Java Applet程序中，我们将探讨如何用Java实现约瑟夫环的算法，并...
java约瑟夫环
10-23
java约瑟夫环
约瑟夫环游戏java
06-11
一群人围成一圈从123报数，如果报到3就退出该圈中，直到最后一个人留下来！
Java之约瑟夫环
一名小白的进阶之路
01-29 379
约瑟夫环：假设有N人坐在一起，现在给他们编号1-N，现在选取编号每次是k的倍数的人出局，直至最后留下一个人。 题目：假设现在有8人，给他们编号1,2，....，8，现在选取编号是3的倍数的人出局，请问最后一个幸运的人编号是几？ 结果：当传入参数为8时，输出结果为7。 ...
约瑟夫环基本版（java）
仔仔木的博客
01-07 1296
约瑟夫环基本版（java）问题描述代码代码讲解运行结果 问题描述 问题描述：N个人围成一圈，从第M个人开始报数，报到K的人出圈，剩下的人继续从1开始报数，报到K的人出圈；如此往复，直到所有人出圈。（模拟此过程，输出出圈的人的序号） 代码 import java.util.Arrays; public class Joseph { public static void main(String[] args) { final int N=8; //人数 final int M=2; //开始报
约瑟夫环（Josepfu） Java实现
m0_63077733的博客
10-27 1850
关于约瑟夫环的学习思路和代码
约瑟夫环（Java）
L的博客
08-14 320
约瑟夫环问题描述：       约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为1的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。输入：两个整数n，m，如上所述。输出：出列人的编号代码：import java.util.Scanner;public class Jos
java 约瑟夫环_java 约瑟夫环 循环
weixin_32645721的博客
02-12 143
展开全部importjava.util.*;publicclassSefu{publicstaticvoidmain(String[]args){e69da5e887aa62616964757a686964616f31333332643263intN;//总人数intM;//从第M个人开始intS;//隔S个人出局Scannerreader=newScanne...
Java实现约瑟夫环
weixin_35757191的博客
12-19 698
约瑟夫环(Josephus Problem)是一个著名的数学问题。 假设有 n 个人围成一圈，从第一个人开始报数，每次数到 m 的人会被杀死，直到最后剩下一个人。 下面是一个用 Java 语言实现约瑟夫环的示例代码： import java.util.LinkedList; public class JosephusProblem { public static int lastRema...
Python如何实现约瑟夫环？
最新发布
05-07
约瑟夫环是一个经典的问题，可以用Python来实现。下面是一个示例代码： ```python def josephus(n, k): if n == 1: return 1 else: return (josephus(n-1, k) + k-1) % n + 1 n = 7 k = 3 print("The chosen ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值