【数据结构与算法】约瑟夫(Josephu)问题

什么是约瑟夫问题呢？

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

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

解题思路

• 构建单向的环形链表

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

• 遍历环形链表

1. 先让一个辅助指针变量指向first节点
2. 通过一个while循环遍历该环形链表

代码实现

约瑟夫问题中环形链表：

public class CircleSingleLinkedList {
    // 创建一个first结点，当前没有编号
    private Boy first=null;
    // 添加小孩结点，构建成一个环形的链表
    public void addBoy(int nums){
        // nums 做一个数据校验
        if (nums<1){
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy =null;
        // 使用for来创建我们的环形链表
        for (int i = 1; i <=nums; i++) {
            Boy boy=new Boy(i);
            // 判断是否为第一个
            if (i==1){
                first=boy;
                first.setNext(first); // 构建环形
                curBoy=first;// 让curBoy指向第一个
            } 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.println("链表指针编号"+curBoy.getNo());
            if (curBoy.getNext()==first){
                break;
            }
            curBoy=curBoy.getNext();// curBoy往后移动
        }
    }
    public void countBoy(int startNo,int countNum,int nums){
        if (first==null ||startNo<1|| startNo>nums){
            System.out.println("参数出现错误~");
            return;
        }
        // 创建要给辅助指针，帮助完成结点出环形列表
        Boy helper=first;
        // 此辅助指针应该指向环形链表的最后一个结点
        while (true){
            if (helper.getNext()==first){
                break;
            }
            helper=helper.getNext();
        }
        for (int i = 0; i < startNo-1; i++) {
            first=first.getNext();
            helper=helper.getNext();

        }
        // 循环操作，环形链表中只有一个结点
        while (true){
            if (helper==first){
                break;
            }
            for (int i = 0; i < countNum-1; i++) {
                first=first.getNext();
                helper=helper.getNext();
            }
            // first指向的结点就是要出环形链表的结点
            System.out.println("出环形链表的结点"+first.getNo());

            // first指向的结点离开环形链表
            first=first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后留下的编号"+first.getNo());
    }
}

环形链表中的结点：

public class Boy {
    private int no; // 编号
    private Boy next;// 指向下一个结点，默认为null

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

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

测试：

    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList=new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();

        System.out.println("==============================");
        circleSingleLinkedList.countBoy(1,2,5);
    }

结果：