数据结构 - 约瑟夫环

约瑟夫问题由来

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

约瑟夫环介绍

Josephus(约瑟夫、约瑟夫环) 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数 到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由 此产生一个出队编号的序列。

提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

单向环形列表

构建一个单向的环形链表思路

1. 先创建第一个节点， 让first指向该节点，并形成环形。
2. 后面当我们每创建一个新的节点，就把该节点加入到已有的环形链表中即可。

遍历环形链表

1. 先让一个辅助指针(变量)curBoy，指向firs节点。
2. 然后通过一个while循环遍历该环形链表即可 当 curBoy.next == first 遍历结束。

出队编号的顺序分析

1. 需要创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这一个节点。
2. 小孩报数前，先让first和helper指针同时移动 k-1 次（从第几个人开始报数）。
3. 当小孩报数时，让first 和 helper指针同时的移动 m-1 次（helper 永远在 first 后边 便于删除）。
4. 这时候就可以考虑将first指向的节点出圈。first = first.next; helper.next = first；
5. 原来first指向的节点就没有任何引用，就会被回收。

代码实现

/**
 * 解决约瑟夫问题
 */
public class Josephus {
    public static void main(String[] args) {
        // 测试构建环形链表和遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        // 加入5个小孩
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();

        // 测试小孩出圈 3->1->5->2->4
        System.out.println("=====约瑟夫问题======");
        circleSingleLinkedList.countBoy(1, 3, 5);
    }
}

/**
 * 创建一个环形的单向链表
 */
class CircleSingleLinkedList {
    /**
     * 创建一个first节点，当前没有编号
     */
    private Boy first = null;

    /**
     * 添加小孩节点，构建一个环形链表
     * @param nums
     */
    public void addBoy(int nums) {
        // nums做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
        }
        // 辅助指针，帮助构建环形链表
        Boy curBoy = null;
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                // 构成环
                first.setNext(first);
                // 让temp指向第一个小孩
                curBoy = first;
            } else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

    /**
     * 遍历当前的环形链表
     */
    public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("没有任何小孩~");
            return;
        }
        // 因为first不能动，所以我们还需要使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号%d \n", curBoy.getNo());
            // 说明遍历完毕
            if (curBoy.getNext() == first){
                break;
            }
            // temp后移
            curBoy = curBoy.getNext();
        }
    }

    /**
     * 根据用户的输入，计算出小孩出圈的顺序
     * @param firstNo 表示小孩从第几个小孩开始报数
     * @param countNum 表示一次数几下
     * @param nums 表示最初有多少个小孩在圈中
     */
    public void countBoy(int firstNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || firstNo < 1 || firstNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建辅助指针
        Boy helper = first;
        // 需求创建一个辅助指针变量helper，事先应该指向环形链表的最后这个节点
        while (true) {
            // 说明helper指向了最后小孩节点
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让first和helper移动firstNo-1次 移动到报数小孩的位置
        for (int j = 0; j < firstNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，，让first和helper指针同时移动m-1此，然后出圈
        while (true) {
            // 说明圈中只有一节点
            if (helper == first) {
                break;
            }
            // 让first和helper指针同时的移动countNum-1
            for (int j = 0; j < countNum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的节点，就是小孩要出圈的节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            // 这是将first指向的小孩出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号%d\n", first.getNo());
    }

}

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

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

    public int getNo() {
        return no;
    }

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

    public Boy getNext() {
        return next;
    }

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

测试

小孩的编号1 
小孩的编号2 
小孩的编号3 
小孩的编号4 
小孩的编号5 
=====约瑟夫问题======
小孩3出圈
小孩1出圈
小孩5出圈
小孩2出圈
最后留在圈中的小孩编号4

Process finished with exit code 0

😘