数据结构与算法--单向循环链表解决约瑟夫问题

---

一、什么是约瑟夫问题

约瑟夫问题（有时也称为约瑟夫斯置换，是一个计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。又称“丢手绢问题”）

二、约瑟夫问题举例

1.题目描述

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

2.解题思路

先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

3.图例分析

三、代码示例

/**
 * 单向循环链表解决约瑟夫问题
 * @author xzt
 * @create 2021-01-04 14:08
 */
public class JosephDemo {

    public static void main(String[] args) {
        CircularLinkedList circularLinkedList = new CircularLinkedList();

        circularLinkedList.add(5);

        circularLinkedList.show();

        circularLinkedList.countBoy(1,2,5);

    }

}

//单向循环链表类
class CircularLinkedList{
    private Boy first = null;//定义first指针，用来指向第一个节点

    //添加节点，构建一个单向环形链表
    public void add(int num){
        if(num < 1){
            System.out.println("输入的num不合法");
            return;
        }

        //定义一个临时变量用来，指向当前的节点，帮助构建环形链表
        Boy currBoy = null;

        for (int i = 1; i <= num; i++){
            Boy boy = new Boy(i);
            if(i == 1){
                first = boy;
                currBoy = first;
                first.setNext(currBoy);
            }else{
                currBoy.setNext(boy);
                boy.setNext(first);
                currBoy = boy;
            }
        }
    }

    //遍历当前的环形链表
    public void show(){
        if(first == null){
            System.out.println("没有任何节点");
            return;
        }

        //因为first不能移动，定一个辅助指针完成遍历
        Boy temp = first;

        while (true) {
            System.out.println("小孩的编号:"+temp.getNo());
            if(temp.getNext() == first){
                break;
            }
            temp = temp.getNext();
        }
    }

    /**
     * 出圈操作
     * @param startNum  表示从第几个开始数
     * @param countNum  表示数几下
     * @param num   表示一开始有多少小孩在圈中
     */
    public void countBoy(int startNum,int countNum,int num){
        if(first == null || startNum < 0 || countNum > num){
            System.out.println("参数输入有误，请重新输入");
            return;
        }

        //定义一个变量来辅助出圈操作，其永远在出圈节点的后一个节点
        Boy helper = first;

        //初始先将helper指向first节点的后一个节点，即最后一个节点
        while(true){
            if(helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }

        //根据startNum，即从第几个节点开始数，应该将first和helper移动到startNum-1的位置（因为这里first节点自身算一次）
        for (int i = 0; i < startNum-1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        //都移动到开始的指定位置后，开始出圈操作
        while(true){
            if(first == helper){//如果此时first等于helper说明此时链表中就还剩当前一个节点，出圈操作完成
                break;
            }

            //开始数
            for (int i = 0; i < countNum-1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            System.out.println("小孩"+first.getNo()+"出圈");
            //此时，将first指向下一个节点，helper下一个改指向first，实现出圈操作
            first = first.getNext();
            helper.setNext(first);
        }

        System.out.println("最后留在圈中的小孩编号"+first.getNo());

    }

}


//节点类
class Boy{
    private int no;//编号
    private Boy next;//指向下一个的指针

    public Boy() {
    }

    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;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }
}