6、链表-单向环形链表

来源：https://www.bilibili.com/video/BV1B4411H76f?p=28

一、约瑟夫问题

n个人围成一圈，从编号为k(1 ≤ k ≤ n)的那个人开始数，数到m的那个人出列。想要按照出列的顺序把这些人依次指出。

这样的约瑟夫问题可以通过一个没有头结点的单向环形链表处理。结点数目为n，从第k个结点开始计数，按照链表顺序一直计数到m，将m对应的这个人删除。

举一个n=5 k=1 m=2的例子

二、思路

2.1 创建单向环形链表的思路

1、创建第一个结点，让first指针指向该节点，同时该节点与自身形成环

2、后面需要知道当前创建的环形链表的大小，即上述约瑟夫问题中的n。将n个新结点加入到已有的环形链表中。

2.2 遍历单向环形链表的思路

1、辅助指针指向first结点

2、利用while循环，直到【当前结点.next】=【first】

2.3 约瑟夫问题的解决思路

1、为了避免整个环形链表断掉，必须在要出去的结点前面加一个辅助结点helper,当前结点first出去之后，

【first】=【first.next】

【helper.next】=【first】

2、因为整个问题开始的时候，first指向的是第一个创建的结点的位置，所以可以把helper之前它的前面，也就是环形的最后一个结点。当知道从编号为k的那个结点开始之后，两个指针同时后移相应的位置，令first指向开始的结点，helper指向前一个。

3、开始报数之后，也是first、helper指针同时移动，直到走到要删除的结点。

三、实现

3.1 创建单向环形链表

1、新建一个对应于约瑟夫问题的结点类，编号属性代表的是第几个人，next属性指向下一个人。

public class Node3 {
    private int no;
    private Node3 next;

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

    public int getNo() {
        return no;
    }

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

    public Node3 getNext() {
        return next;
    }

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

 2、创建一个单向环形链表类CircleSingleLinkedList，类中有一个first结点，代表要创建的链表的第一个结点。在类中加入了利用输入的结点个数构建环形链表的方法，以及通过遍历的方式展示整个环形链表的方法。

public class CircleSingleLinkedList {
    //创建第一个结点
    private Node3 first = new Node3(-1);

    //构建环形链表
    //为了简化，结点中只有编号这个属性，针对约瑟夫问题，编号顺序递增排列，但是需要知道有多少个人nums围成一圈
    public void addNode(int nums){
        if(nums < 1){
            System.out.println("参数nums错误");
            return;
        }
        Node3 curNode = null;//辅助指针，指向当前结点
        for (int i = 1; i <= nums; i++) {
            Node3 node3 = new Node3(i);

            if(i == 1){
                //第一个结点，需要利用first自己形成环形
                //之后first就不再动了，由curNode辅助指针完成之后的操作
                first = node3;
                first.setNext(first);
                curNode = first;
            }else {
                curNode.setNext(node3);
                node3.setNext(first);
                curNode = node3;
            }
        }
    }

    //遍历，显示环形链表
    public void show(){
        if(first.getNo() == -1){
            System.out.println("链表为空");
            return;
        }
        Node3 curNode = first;
        while (true){
            System.out.printf("当前结点的编号为%d",curNode.getNo());
            System.out.println();
            if(curNode.getNext() == first){
                System.out.println("遍历完毕");
                break;
            }
            curNode = curNode.getNext();
        }
    }
}

测试，这里加入了5个结点（5个人围成一圈），构成环形链表

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

        circleSingleLinkedList.show();
        System.out.println();

        circleSingleLinkedList.addNode(5);

        circleSingleLinkedList.show();

    }

结果

链表为空

当前结点的编号为1
当前结点的编号为2
当前结点的编号为3
当前结点的编号为4
当前结点的编号为5
遍历完毕

3.2 约瑟夫问题

在CircleSingleLinkedList类中加入一个统计出圈顺序的方法

    //约瑟夫问题，
    // 根据用户输入的
    // **围成一圈的人的数目nums，
    // **从编号startNo开始，
    // **数到m的那个人出圈
    // 排列出圈的顺序
    public void countNode(int nums, int startNo, int m){
        if(first.getNo() == -1 || startNo < 1 || startNo > nums){
            System.out.println("参数错误");
            return;
        }

        Node3 helper = first;//辅助指针
        //令辅助指针指向first的前一个位置
        while (true){
            if(helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }

        //将first和helper定位到开始的位置startNo
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        //开始报数
        while (true){
            //循环结束的标志是：只剩最后一个人了，first和helper指针都在他上面
            if(first == helper){
                break;
            }
            //数到m
            for (int i = 0; i < m - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //first指向的第m个人要出圈
            System.out.printf("%d出圈",first.getNo());
            System.out.println();
            first = first.getNext();//出圈时，first要重新定位
            helper.setNext(first);//helper的下一个也要重新指定
        }
        //输出一下最后剩的那个结点
        System.out.printf("最后一个是%d",first.getNo());
    }

测试，在上面测试的基础上进行（已经插入了5个结点）

        circleSingleLinkedList.countNode(5,1,2);

结果，与上面图中的顺序完全一致

2出圈
4出圈
1出圈
5出圈
最后一个是3