5. 环形链表实现约瑟夫问题

一、概念

1. 环形链表

环形链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向第一个结点，整个链表形成一个环。

2. 约瑟夫问题

设编号为1，2，…，n 的n个人围坐一圈，约定编号为 k (1 ≤ k ≤ n) 的人从1开始报数，数到m的那个人出列，出列的人的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人都出列为止，由此产生一个出队编号的队列。

二、环形链表和约瑟夫问题的实现

1. 环形链表的实现

思路：

1. 先定义一个 first 变量初始值为空，目的是让 first 指向环形链表的第一个结点；
2. 为保证first变量不能移动，所以应该定义一个辅助变量 curr 来帮助后续的结点加入构成环形链表，curr的初始值也为null；
3. 在加入第一个结点时，就让 first 指向该节点，first的next指向自己，curr此时处于第一个结点的位置，
   即first = boy，first.next = first，curr = first，从而形成一个环；
4. 从加入第二个节点开始，就让 curr 变量 next 指向这个加入的新结点，新结点的 next 指向第一个结点，
   即curr.next = newBoy，newBoy.next = first，curr = boy；
5. 后面当我们每创建一个新结点，就把该结点加入到已有的环形链表中即可。

代码实现：

/**
 * 创建小孩节点
 */
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;
    }
}

/**
 * 创建管理小孩节点的环形链表
 */
class CircleSingleLinkedList {
    private Boy first = null;

    /**
     * 添加小孩结点
     * @param nums 表示要创建的结点个数
     */
    public void addBoy(int nums) {
        // nums 做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curr = null; // 辅助指针，帮助构建环形链表
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); // 构成环
                curr = first; // 让curBoy指向第一个小孩结点
            } else {
                curr.setNext(boy); //新结点加在curr后面
                boy.setNext(first); //新结点的next指向第一个结点,从而形成一个环
                curr = boy; //curr后移
            }
        }
    }
	/**
     * 遍历当前的循环链表
     */
    public void showBoy() {
        if (first == null) {
            System.out.println("当前小孩链表没有结点~");
        }
        //因为first不能移动,所以定义一个辅助指针指向第一个结点,帮助遍历环形链表
        Boy curr = first;
        while (true) {
            System.out.printf("当前小孩结点的编号为%d \n",curr.getNo());
            //已经遍历到最后一个结点了
            if (curr.getNext() == first) {
                break;
            }
            //curr后移
            curr = curr.getNext();
        }
    }

}

2. 环形链表实现约瑟夫问题

思路：

1. 先创建一个环形链表，用来模拟 n 个小孩围成的圈，first 指向环形链表的第一个结点(这里 first 可以移动，但寓意上 first 还是表示环形链表的第一个结点)；
2. 创建个helper的辅助变量，一开始指向环形链表的最后一个结点；
3. 因为一开始 first 指向环形链表的第一个结点，helper一开始指向环形链表的最后一个结点，而约瑟夫问题是让第 k 个人开始报数，所以我们让 first 和 helper 移动 k-1 次，即此时第 k 个小孩结点成为了当前链表的第一个结点；
4. 第 k 个人开始报数，报数 m 次后所表示的那个人就需要出圈，所以此时让 first 和 helper 移动 m - 1 次(此时first指向了要出圈的这个结点，first表示要出圈的前一个结点)，再让first = first.next，helper.next = first，这就保证了要出圈的这个结点没有任何引用，被回收；循环重复以上操作，直到圈里只剩下了一个人为止，此时helper == first；
5. 如果结点顺序为 1 → 2 → 3 → 4 → 5，，从第1个节点开始报数，报数2次，
   则出圈顺序为2 → 4 → 1 → 5 → 3。

代码实现：

package com.banmingi.datastructures.linkedlist;

/**
 * @auther 半命i 2020/1/11
 * @description 环形链表实现约瑟夫问题
 */
public class Josephus {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        //circleSingleLinkedList.showBoy();
        circleSingleLinkedList.josephusProblem(1,2,5);
    }
}

/**
 * 创建管理小孩节点的环形链表
 */
class CircleSingleLinkedList {
    private Boy first = null;

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

    /**
     * 遍历当前的循环链表
     */
    public void showBoy() {
        if (first == null) {
            System.out.println("当前小孩链表没有结点~");
        }
        //因为first不能移动,所以定义一个辅助指针指向第一个结点,帮助遍历环形链表
        Boy curr = first;
        while (true) {
            System.out.printf("当前小孩结点的编号为%d \n",curr.getNo());
            //已经遍历到最后一个结点了
            if (curr.getNext() == first) {
                break;
            }
            //curr后移
            curr = curr.getNext();
        }
    }


    /**
     * 环形链表实现约瑟夫问题.
     * @param startNo 表示从第几个小孩开始数数
     * @param countNum 表示数几下
     * @param nums 表示最初有多少小孩在圈中
     */
    public void josephusProblem(int startNo,int countNum,int nums) {
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误， 请重新输入");
            return;
        }

        //创建一个辅助变量helper,并让其一开始指向环形链表的最后一个结点
        Boy helper = first;
        while (true) {
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }

        //从第 startNo 个结点开始报数,所以让helper 和 first 移动 startNo-1 次
        for (int i=1; i<=startNo -1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        //找到第startNo个结点后,开始循环地报数,每次报countNum,直到链表中只剩下一个结点为止
        while (true) {
            //圈中只有一个结点
            if (helper == first) {
                break;
            }
            //first 和 helper 移动 countNum-1 次,找到要出圈的那个结点
            for (int i=1; i<=countNum-1;i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //此时first指向的结点就是要出圈的结点
            System.out.printf("要出圈的结点为%d \n",first.getNo());
            //出圈
            first = first.getNext();
            helper.setNext(first);
        }
        //圈中剩下的最后一个结点
        System.out.printf("最后出圈的结点为%d \n",first.getNo());
    }
}

/**
 * 创建小孩节点
 */
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;
    }
}

测试结果：