使用循环单链表解决约瑟夫问题

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

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

以1，2，3，4，5 为例，

n=5,k=1,m=2

出队编号为2,4,1,5,3

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

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

    //生成循环单链表
    public void cricleList(int n){
        if(n<1){
            System.out.println("data error");
            return;
        }
        
        Node cur=null;
        for(int i=1;i<=n;i++){
            Node node=new Node(i);
            if(i==1){
                first=node;
                node.setNext(first);
            }else{
                cur.setNext(node);
                node.setNext(first);
            }
            cur=node;
        }
    }

遍历环形链表

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

•     //遍历
      public void list(){
          if(first==null){
              System.out.println("循环单链表为空..");
              return;
          }
          Node cur=first;
          while(true){
              System.out.println("node "+cur.getNo());
              if(cur.getNext()==first){
                  break;
              }
              cur=cur.getNext();
          }
      }

   

节点出圈思路

• 1.需要创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这个节点
• 补充：节点报数前，先让first和helper移动k-1次
• 2.当节点报数时，让first 和helper指针同时的移动m-1次
• 3.这时就可以将first指向的节点出圈

            first= first.next

            helper.next = first

            原来first指向的节点就没有任何引用，就会被回收

public void out(int n,int k,int m){

        if(first==null||k<1||k>n){
            System.out.println("data error");
            return;
        }
        
        //1.
        Node helper=first;
        while(true){
            if(helper.getNext()==first){
                break;
            }
            helper=helper.getNext();
        }

        //1.1
        for(int i=0;i<k-1;i++){
            first=first.getNext();
            helper=helper.getNext();
        }

        //3.
        while(true){
            if(helper==first){
                break;
            }
            //2.
            for(int i=0;i<m-1;i++){
                first=first.getNext();
                helper=helper.getNext();
            }
            System.out.println("出圈 node:"+first.getNo());

            first=first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后一个节点："+first.getNo());
    }

完整代码实现

//约瑟夫问题 求解
//使用循环单链表

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

class CircleSingleLinkedList{

    private Node first=null;

    //生成循环单链表
    public void cricleList(int n){
        if(n<1){
            System.out.println("data error");
            return;
        }
        //需要区分第一个节点和后面的节点 分情况
        Node cur=null;
        for(int i=1;i<=n;i++){
            Node node=new Node(i);
            if(i==1){
                first=node;
                node.setNext(first);
            }else{
                cur.setNext(node);
                node.setNext(first);
            }
            cur=node;
        }
    }

    //遍历
    public void list(){
        if(first==null){
            System.out.println("循环单链表为空..");
            return;
        }
        Node cur=first;
        while(true){
            System.out.println("node "+cur.getNo());
            if(cur.getNext()==first){
                break;
            }
            cur=cur.getNext();
        }
    }

    //出圈
    public void out(int n,int k,int m){

        if(first==null||k<1||k>n){
            System.out.println("data error");
            return;
        }

        //1.创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点.
        Node helper=first;
        while(true){
            if(helper.getNext()==first){
                break;
            }
            helper=helper.getNext();
        }

        //1.1节点报数前，先让first 和helper移动 k - 1次
        for(int i=0;i<k-1;i++){
            first=first.getNext();
            helper=helper.getNext();
        }

        while(true){
            if(helper==first){
                break;
            }
            //2.节点报数时，让first 和 helper 指针同时的移动m-1次
            for(int i=0;i<m-1;i++){
                first=first.getNext();
                helper=helper.getNext();
            }
            System.out.println("出圈 node:"+first.getNo());

            //3.节点出圈
            first=first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后一个节点："+first.getNo());
    }
}

public class josepfu {

    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList=new CircleSingleLinkedList();
        circleSingleLinkedList.cricleList(5);
        circleSingleLinkedList.list();
        circleSingleLinkedList.out(5,1 ,2 );
    }
}

node 1
node 2
node 3
node 4
node 5
出圈 node:2
出圈 node:4
出圈 node:1
出圈 node:5
最后一个节点：3