约瑟夫环问题

6.4 Josephu约瑟夫问题

josephu问题为：设编号为1、2、... n 的 n 个人围坐一圈，约定编号为 k （1 <= k <= n）的人从 1 开始报数，数到 m 的那个人出列，他的下一位又从 1 开始报数，数到 m 的那个人又出列，依此类推，直到所有人出列位置，由此产生一个出队编号的序列。

假设 n = 5; k = 1; m = 2; 那么出来的队列顺序就是 2 - 4 - 1 - 5 - 3（使用单项环形链表完成，也可以使用数组取模完成）

构建一个单向环形链表

1. 先创建第一个节点，让 first 指向该节点， 并形成环形

2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可

遍历环形链表

1. 先让一个辅助指针（变量），指向 first 节点

2. 然后通过一个 while循环遍历，该环形链表即可，即curBoy.next = first

根据用户的输入，生成一个小孩出圈的顺序

1. 需要创建一个辅助指针helper，事先指向环形链表的最后一个节点

2. 当小孩报数时，让first和helper同时移动 m - 1 次

3. 这时就可以将first执行那个的小孩节点出圈

   first = first.next;

   helper.next = first;

   原来 first指向的节点就没有任何引用，就会被垃圾回收机机制回收

 

package LinckedList;
​
public class Josepfu {
    public static void main(String[] args) {
        // 测试，构建环形链表和遍历是否成功
        CircleSingleLinkedList c1 = new CircleSingleLinkedList();
        c1.addBoy(5); // 加入5个小孩的节点
        c1.showBoy();
​
        // 测试出圈
        c1.countBoy(1,2,5);
    }
}
// 创建一个环形的单向链表
class CircleSingleLinkedList{
    // 创建一个first节点，当前没有编号
    private Boy first = new Boy(-1);
    // 添加小孩的节点，构建一个环形的链表
    public void addBoy(int num){
        // 对num做一个数据校验
        if (num < 1){
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null; //  辅助指针，帮助构建环形链表
        // 使用一个for循环创建我们的环形链表
        for (int i = 1; i <= num; i++) {
            // 根据编号创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1){
                first = boy;
                first.setNext(first); // 构成环
                curBoy = first; // 让curBoy指向第一个小孩
            } else {
                curBoy.setNext(boy); // 先让curBoy指向的节点的下一个指向新节点
                boy.setNext(first); // 在让新节点的指回第一个节点，构成环
                curBoy = boy; // 最后令curBoy后移指向boy，等待下一个新的boy节点
            }
        }
    }
    // 遍历当前环形节点
    public void showBoy(){
        // 判断链表是否为空
        if (first == null){
            System.out.println("NULL");
            return;
        }
        // 因为first 不能动，因此我们使用辅助指针完成遍历
        Boy curBoy = first;
        while (true){
            System.out.printf("小孩的而编号为 %d\n",curBoy.getNo());
            if (curBoy.getNext() == first){
                // 说明遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy后移
        }
    }
​
    // 根据用户输入，计算出小孩出圈的顺序
​
    /**
     *
     * @param startNo 表示从第几个小孩开始报数
     * @param countNum 表示数几下
     * @param nums 表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo, int countNum, int nums){
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums){
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建辅助指针，帮助出圈
        Boy helper = first;
        // 需求创建一个辅助指针helper， 事先应该指向环形链表的最后这个结点
        while (true){
            if (helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }
        // 报数前先让first和helper移动 startNo(k) - 1次
        for (int j = 0; j < startNo - 1; j++){
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让first和helper同时移动 m - 1 次
        // 这里是一个循环的操作,直到圈中只有一个
        while (true){
            if (helper == first){
                break;
            }
            // 让first和helper同时移动 countNum(m) - 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; // 编号
    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;
    }
}

 

​
​