环形链表和约瑟夫问题

1. 约瑟夫问题简介
   Josephu问题为:设编号为1，2, …n的n个人围坐一圈，约定编号为k (1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始损数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
   
   
   单向环形链表图示：
       
2. 用环形单链表解决约瑟夫问题的思路
        思路大概分为两个部分，
          1）一是首先我们需要构建一个单向环形链表，
             
          2）二是把这个链表当成约瑟夫问题中的圈，然后遍历这个单向链表并且按照约定依次取出环形链表中的元素，
               直到所有的元素出列为止，最后产生一个出队编号的序列。
               
          3）最后这个出队编号的序列就是我们想要得到的约瑟夫问题中最后的答案。
3. 下面我们使用代码实现
    1）创建一个单向环形链表
          a: 先创建一个Node类，表示一个节点

   package com.iamp.admin.test;
   
   //创建一个Node类，表示一个节点
   public class Node {
       private int no;//编号
       private Node next;//指向下一个节点
   
       public Node(int no) {
           this.no = no;
       }
   
       public int getNo() {
           return no;
       }
   
       public void setNo(int no) {
           this.no = no;
       }
   
       public Node getNext() {
           return next;
       }
   
       public void setNext(Node next) {
           this.next = next;
       }
   }
   
   

       b: 创建环形链表以及遍历链表

   package com.iamp.admin.test;
   
   public class CirculateSingleLinkedList {
       //创建环形链表
       //创建一个first节点,当前没有编号
       private Node first = new Node(-1);
       //添加节点，构建成一个环形的链表
       public void addNode(int nums){
           //nums 做一个数据校验
           if(nums < 1){
               System.out.println("muns的值不正确");
               return;
           }
           Node curNode = null;//辅助变量，帮助构建链表
           //使用for循环创建环形链表
           for(int i = 1;i <= nums;i++){
               //根据编号，创建节点
               Node node = new Node(i);
               //第一个节点要单独考虑；如果是第一个节点
               if(i==1){
                   first = node;
                   first.setNext(first);//构成一个节点的环
                   curNode = first;//让curNode指向我们的第一个节点。因为first是不能动的
   
               }else{
                   curNode.setNext(node);//让当前节点指向新节点
                   node.setNext(first);//让新节点指向第一个节点
                   curNode = node;//把当前节点赋值给curNode，以便后面继续使用。
               }
   
           }
       }
       //遍历环形链表
       public void showNode(){
           //判断是不是空链表
           if(first == null){
               System.out.println("链表为空");
               return;
           }
           //因为first不能动，因此辅助变量完成遍历
           Node n = first;
           while(true){
               System.out.println("Node的编号"+ n.getNo());
               if(n.getNext() == first){//说明已经遍历完毕
                   break;
               }
               n = n.getNext();//让n后移。
           }
       }
   
   }
   

   
       c：编写main方法测试
    

   package com.iamp.admin.test;
   
   public class Josepfu {
   
       public static void main(String[] args) {
           CirculateSingleLinkedList c = new CirculateSingleLinkedList();
           c.addNode(5);//加入5个节点
           c.showNode();
       }
   
   }
   

   d：效果
     
          
    2）解决约瑟夫问题，即产生一个出队编号的序列。

    public void countNode(int startNo,int countNum,int nums){
       //对数据进行校验
           if(first == null || startNo < 1 || startNo > nums){
               System.out.println("参数输入有误");
               return ;
           }
           //创建一个辅助变量help，帮助Node出圈。
           Node help = first;
           //创建一个辅助变量help，事先指向环形单链表的最后一个节点。
           while (true){
               if(help.getNext() == first){
                   break;
               }else{
                   help = help.getNext();
               }
           }
           //当node报数前，让first和help移动k-1次。其中k表示从第几个开始
           for(int j = 0;j < startNo -1;j++){
               first = first.getNext();
               help = help.getNext();
           }
           //当node报数时，让first和help指针同时移动m-1次,然后出圈
           //这里是一个循环操作，直到圈中只有一个节点
           while (true){
               if(help==first){//说明圈中只有一个点
                   break;
               }//否则让让first和help指针同时移动countNum-1次，然后出圈
               for(int j = 0;j<countNum-1;j++){
                   first = first.getNext();
                   help = help.getNext();
               }
               //此时first指向的节点就是出圈的节点
               System.out.println("节点"+first.getNo()+"出圈");
               //这是将first指向的节点出圈
               first = first.getNext();
               help.setNext(first)  ;
           }
           System.out.println("最后留在圈中的节点是"+ first.getNo());
       }
   
   

   效果：
   可以发现和上面的图一样。

   Node的编号1
   Node的编号2
   Node的编号3
   Node的编号4
   Node的编号5
   ==================开始出圈==================
   节点2出圈
   节点4出圈
   节点1出圈
   节点5出圈
   最后留在圈中的节点是3