数据结构---约瑟夫环问题

单向循环链表

单向循环链表：
在单向链表中，头指针是相当重要的，因为单向链表的操作都需要头指针，所以如果头指针丢失或者破坏，那么整个链表都会遗失，并且浪费链表内存空间。

构建一个单向的环形链表思路

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

遍历环形链表思路

1. 先让一个辅助指针(变量) cur，指向head节点
2. 然后通过一个while循环遍历该环形链表即可 cur.next == head结束

//创建单向的环形链表
class CricleSingleList{
    //创建head节点
    private Node head=new Node(-1);
    //添加一个尾节点，构成一个环形链表
    public void add(int nums){
        //判断num是否合法
        if(nums<1){
            System.out.println("num的值不正确");
            return;
        }
        //创建辅助节点
        Node temp=null;
        for(int i=1;i<=nums;i++){
            //根据编号创建节点
            Node node=new Node(i);
            //如果是第一个节点
            if(i==1){
                head=node;
                head.setNext(node);//成环
                temp=node;//temp执行第一个节点
            }else {
                temp.setNext(node);//大年节点的下一个节点指向新节点
                node.setNext(head);//下一个节点指向头结点，成环
                temp=node;//temp指向新的节点
            }


        }

    }
    //遍历环形链表’
    public void show(){
        //判断链表是否为null
        if(head==null){
            System.out.println("没有节点");
            return;
        }
        //因为头节点没法动，所以无法使用辅助指针完成遍历
        Node cur=head;
        while(true){
            System.out.println("节点的编号: "+cur.getNum());
            if(cur.getNext()==head){
                //说明遍历结束
                break;
            }
            cur=cur.getNext();//当前接地那个先后移动
        }
    }

}



//创建Node类，表示一个节点
class Node{
    private int num;//节点数
    private Node next;//节点的下一个指向
    
    //构造器
    public Node(int num){
        this.num=num;
    }
    
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Node getNext() {
        return next;
    }

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

单向循环链表的应用场景：约瑟夫环

Josephu(约瑟夫、约瑟夫环) 问题

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

提示：

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

分析：

根据用户的输入，生成一个小孩出圈的顺序
n = 5 , 即有5个人
k = 1, 从第一个人开始报数
m = 2, 数2下

1. 需求创建一个辅助指针(变量) temp, 事先应该指向环形链表的最后这个节点.
   • 补充： 小孩报数前，先让 head和 temp移动 k - 1次(开始报数的节点)
2. 当小孩报数时，让head和 temp指针同时 的移动 m - 1 次（数几下出圈）
3. 这时就可以将head指向的小孩节点 出圈
   • head= head.next
   • temp.next = head
     原来head指向的节点就没有任何引用，就会被回收

出圈的顺序
2->4->1->5->3

移动

/*
startNo：表示从第几个节点开始数数
count：表示数几下
nums: 表示最初有几个节点
 */

public  void countNode(int startNo,int count,int nums){
    //判断链表是否为null,或者参数是否有误
    if(head==null||startNo<1||startNo>nums){
        System.out.println("输入有误");
        return;
    }
    //创建临时变量，帮助出圈
    Node temp=head;
    //让temp指向环形链表的最后一个节点
    while(true){
        if(temp.getNext()==head){//说明temp 的下一个节点是头结点
            break;
        }
        temp=temp.getNext();
    }

    //当报数时，让head节点和temp节点同时移动k-1次，因为从第K个节点开始遍历
    for(int i=0;i<startNo-1;i++){
        head=head.getNext();
        temp=temp.getNext();
    }
    //当报数时，让head节点和temp节点同时移动m-1次，然后出圈
    //出圈。直到还有一个节点
    while(true){
        if(temp==head){//说明圈里只有一个人
            break;
        }
        //让head和temp同时移动count-1次
        for(int j=0;j<count-1;j++ ){
            head=head.getNext();
            temp=temp.getNext();
        }
        //这是head指向的节点就是要出圈的节点
        System.out.println("出圈节点： "+head.getNum());
        //这时将节点出圈
        head=head.getNext();
        temp.setNext(head);
    }
    System.out.println("最后的节点："+head.getNum());

}