关于java约瑟夫问题，如何解决

部队 N企战士（编号为1-N）站成一排，按顺序循环重复
报数（M 为一个轮回， M-N)，当战士报数为 M 时，该战士出列，接着从1开始报数。请输出战士出列的顺序。

看看我的，也许对你有帮助

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("总人数：");
        int N = sc.nextInt();
        System.out.println("报数：");
        int M = sc.nextInt();

        List<Integer> soldiers = new ArrayList<>();
        for (int i = 1; i <= N; i++) {
            soldiers.add(i);
        }

        List<Integer> result = new ArrayList<>();
        int count = 0;
        int index = 0;

        while (!soldiers.isEmpty()) {
            count++;
            if (count % M == 0) {
                result.add(soldiers.remove(index));
            } else {
                index++;
            }

            if (index >= soldiers.size()) {
                index = 0;
            }
        }

        System.out.println("战士出列的顺序: ");
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}

其实主要就是使用循环和条件判断来模拟报数和出列的过程。最后打印出战士出列的顺序。

假如 N=10 和 M=3 进行测试 , 效果如图 :

代码如下, 如有帮助给个采纳谢谢

import java.util.ArrayList;
import java.util.List;

public class SoldierCircle {
    public static List<Integer> getSoldierOrder(int N, int M) {
        List<Integer> order = new ArrayList<>();
        List<Integer> soldiers = new ArrayList<>();

        // 初始化战士列表
        for (int i = 1; i <= N; i++) {
            soldiers.add(i);
        }

        int idx = 0;
        while (!soldiers.isEmpty()) {
            idx = (idx + M - 1) % soldiers.size();
            order.add(soldiers.get(idx));
            soldiers.remove(idx);
        }

        return order;
    }

    public static void main(String[] args) {
        int N = 10; // 战士数量
        int M = 3; // 报数的轮回

        List<Integer> order = getSoldierOrder(N, M);

        System.out.println("出列顺序：");
        for (Integer soldier : order) {
            System.out.print(soldier + " ");
        }
    }
}

您好，我是有问必答小助手，您的问题已经有小伙伴帮您解答，感谢您对有问必答的支持与关注！
PS：问答VIP年卡 【限时加赠：IT技术图书免费领】，了解详情>>> https://vip.csdn.net/askvip?utm_source=1146287632

• 以下回答由chatgpt基于相关博客总结生成:

  首先，让我们来解决约瑟夫问题。

  约瑟夫问题是一个经典的问题，可以使用循环链表的方式来解决。下面是使用Java编程解决约瑟夫问题的步骤：

  第一步：创建一个节点类，用于表示战士节点。

  class Soldier {
    int id;
    Soldier next;
  
    public Soldier(int id) {
      this.id = id;
      this.next = null;
    }
  }
  

  第二步：创建一个循环链表类，用于管理战士节点。

  class CircularLinkedList {
    private Soldier head;
  
    public CircularLinkedList(int n) {
      head = new Soldier(1);
      Soldier cur = head;
      for (int i = 2; i <= n; i++) {
        cur.next = new Soldier(i);
        cur = cur.next;
      }
      cur.next = head;
    }
  
    public void eliminateSoldier(int m) {
      Soldier cur = head;
      while (cur.next != cur) {
        for (int i = 1; i < m - 1; i++) {
          cur = cur.next;
        }
        System.out.println("Soldier " + cur.next.id + " is eliminated.");
        cur.next = cur.next.next;
        cur = cur.next;
      }
      System.out.println("The remaining soldier is " + cur.id + ".");
    }
  }
  

  第三步：在主函数中调用循环链表类，并输入战士数量和报数值。

  public class Main {
    public static void main(String[] args) {
      int n = 10; // 战士数量
      int m = 3; // 报数值
      CircularLinkedList list = new CircularLinkedList(n);
      list.eliminateSoldier(m);
    }
  }
  

  运行以上代码，即可正确输出战士出列的顺序。

  请注意，这里的代码是一种解决方案，并不是唯一的解决方案。你也可以使用其他的数据结构和算法来解决约瑟夫问题。