【Java】三种方法实现约瑟夫环

背景

约瑟夫环（Josephus）问题的背景可以追溯到公元1世纪，当时犹太历史学家约瑟夫和他的同伴被罗马军队包围。为了避免被俘或杀害，他们决定通过自杀的方式结束生命。为了执行这个决定，他们围成一个圈，然后按照一定的规则来选择自杀的人，直到只剩下最后一个人。这个规则是每次报数到某个固定的数字时，就将当前的人杀掉，然后再由下一个人重新开始报数。

约瑟夫作为一个不愿意自杀的人，快速地计算出了一个位置，使得他成为了最后一个存活的人，从而有机会逃脱。这个问题后来被称为“约瑟夫环”问题，并被广泛应用于计算机科学和数学领域。

题目

已知 n 个人（以编号1，2，3 … n 分别表示）围成一圈。从编号为 1 的人开始报数，数到 m 的那个人出列；他的下一个人又从 1 开始报数，数到 m 的那个人又出列；依此规律重复下去，直到最后剩下一个人。要求找出最后出列的人的编号

方法一：单向循环链表

package com.mobai.study0220;

/**
 * @Author Mobai
 * @Date 2024/2/20 18:03
 * @Version 1.0
 */
class Node {
    int number; // 编号
    Node next; // 指向下一个节点的引用

    public Node(int number) {
        this.number = number;
        this.next = null;
    }
}

class JosephusCircle {
    Node head; // 链表头节点

    // 添加节点到单向循环链表
    public void addNode(int count) {
        Node node = new Node(1); // 假设编号从1开始
        head = node;
        Node current = node;
        for (int i = 2; i <= count; i++) {
            Node newNode = new Node(i);
            current.next = newNode;
            current = newNode;
        }
        current.next = head; // 形成循环
    }

    // 解决约瑟夫环问题，返回最后一个存活者的编号
    public int solveJosephusProblem(int skip) {
        if (head == null) {
            return -1; // 链表为空
        }
        Node current = head;
        Node prev = null;
        while (current.next != current) { // 链表中不止一个节点
            for (int i = 1; i < skip; i++) {
                prev = current;
                current = current.next;
            }
            // 移除当前节点
            prev.next = current.next;
            current = prev.next;
        }
        return current.number; // 返回最后一个存活者的编号
    }
}

public class JosephusSolution {
    public static void main(String[] args) {
        JosephusCircle circle = new JosephusCircle();
        int totalPeople = 10; // 总人数
        int skipCount = 3; // 报数到3的人出列

        // 添加节点到链表
        circle.addNode(totalPeople);

        // 解决约瑟夫环问题
        int lastAlive = circle.solveJosephusProblem(skipCount);

        // 输出最后一个存活者的编号
        System.out.println("最后一个存活者的人的编号是: " + lastAlive);
    }
}

方法二：数组

package com.mobai.study0220;

/**
 * @Author Mobai
 * @Date 2024/2/20 18:32
 * @Version 1.0
 */
public class JosephusArray {
    public static void main(String[] args) {
        int totalPeople = 10; // 总人数
        int skipCount = 3; // 报数到skipCount-1的人出列

        int[] people = new int[totalPeople];
        for (int i = 0; i < totalPeople; i++) {
            people[i] = i + 1; // 初始化数组，人的编号从1开始
        }

        int index = solveJosephus(people, skipCount);
        System.out.println("最后存活的人的编号是: " + (index + 1)); // 输出最后存活者的编号，数组索引从0开始
    }

    public static int solveJosephus(int[] people, int skip) {
        int count = people.length;
        int index = 0; // 当前报数的人的索引

        while (count > 1) {
            // 报数skip-1次后，移除当前人
            for (int i = 0; i < skip - 1; i++) {
                index = (index + 1) % count; // 循环到数组的末尾时回到开头
            }
            // 移除当前人
            people[index] = people[count - 1]; // 将最后一个人移到当前位置
            count--; // 人数减一
        }

        // 返回最后存活者的索引
        return index;
    }
}

方法三：递归

package com.mobai.study0220;

/**
 * @Author Mobai
 * @Date 2024/2/20 19:01
 * @Version 1.0
 */
public class JosephusRecursion {

    // 递归函数，计算最后存活的人的编号
    public int josephus(int n, int m) {
        if(n == 1)   return n;
        return (josephus(n - 1, m) + m - 1) % n + 1;
    }

    // 主方法，用于测试josephus函数
    public static void main(String[] args) {
        JosephusRecursion josephus = new JosephusRecursion();

        // 设置总人数和报数间隔
        int totalPeople = 3;
        int skipCount = 3;

        // 计算并打印最后存活的人的编号
        int lastPerson = josephus.josephus(totalPeople, skipCount);
        System.out.println("最后存活的人的编号是: " + lastPerson);
    }
}