约瑟夫问题的环形链表-- Java

1.链表是以节点的方式去进行相应的存储的
2.每个节点包括data域，和next域，指向下一个节点
3.发现链表的各个节点不一定是连续的
4.链表分带头节点的链表和没有头节点的链表，根据实际的需求而定

链式存储

单向链表，增删改查

当我们需要按照编号的顺序进行添加的时候，这个我们就可以根据一个辅助指针去查找
新的节点的next=temp。next
我们要通过遍历去找到的

从点链表中删除这个节点的思路
1.我们先要去找找到，需要删除节点的前一个节点

temp.next=temp.next.next
这样的话，被删除的节点将不会被做任何的处理，就会被java的垃圾回收机制，进行一个处理

介绍了链表的基本概念
小结
链表就是链式存储
不是一一连续的
单列表的逻辑示意图
看起来是连续的
但是实际上并不是连续的
添加

添加遍历

根据排名进行一个相关的插入

修改节点的代码实现

先找到这个节点，通过遍历的方式
这个修改直接去使用这个this就可以了

双向链表
这个next是指向下一个节点的
这个pre是指向上一个节点的


单向链表不能去实现自我删除
遍历，crud

约瑟夫环问题

创建的思路

package Java.DataStructuresAndAlgorithms.DataStructures.LinkedList;

public class Josepfu {
    public static void main(String[] args) {
        //测试构建的环形链表
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();

        circleSingleLinkedList.addBoy(25);//加入5个小孩
        circleSingleLinkedList.showBoy();

        circleSingleLinkedList.countBoy(1, 2, 5);

    }
}

//创建一个环形的单向链表
class CircleSingleLinkedList {
    //创建一个first节点，当前没有编号
    private Boy first = null;

    public void addBoy(int nums) {
        if (nums < 1) {
            System.out.println("nums is not true");
            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;
            } 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.printf("小孩的编号%d \n", curBoy.getNo());
            if (curBoy.getNext() == first) {
                break;
            }
            curBoy = curBoy.getNext();//让curBoy后移
        }
    }

    //根据用户的输入，计算出小孩的出题顺序
    /**
     * startNo表示从第几个小孩开始去数
     * countNum表示数几下
     * nums表示最初有多少小孩在圈中
     */
    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();
        }
        //小孩报数之前，我们先让这个firsy和helper移动k-1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        while (true) {
            if (helper == first) {
                break;
            }
            for (int j = 0; j < countNum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            System.out.printf("小孩%d已经出圈了\n", first.getNo());

            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() {
        //     this.no = no;
        // }

        public Boy getNext() {
            return next;
        }

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