单环形链表解决约瑟夫环

背景：

约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。

public class CircleLinkList {
    /**
     * 约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，
     * 最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
     *
     *
     */
     private People head=null;

     public void addNode(People people){
         if(head==null){
             head=people;
             head.setNext(people);
             return;
         }
         People temp=head;
         while (true){
            if(temp.getNext()==head){
                break;
            }
            temp=temp.getNext();
         }
         if(temp==head){
             //只有一个节点
             head.setNext(people);
             people.setNext(head);
             return;
         }
         people.setNext(temp.getNext());
         temp.setNext(people);
     }

     private void printList(){
         People temp=head;
         if(temp==null){
             return;
         }
         if(temp==temp.getNext()){
             System.out.println(temp);
             return;
         }
         while (true){
             System.out.println(temp);
             temp=temp.getNext();
             if(temp==head){

                 break;
             }
         }
     }

     public void delNode(People people){
         if(head==null){
             return;
         }
         if(people==head && head.getNext()==head){ //只有一个节点
             head=null;
             return;
         }
         People temp=head;
         while (true){
             if(temp.getNext()==people){
                 break;
             }
             if(temp.getNext()==head){
                 break;
             }
             temp=temp.getNext();
         }
         People next = temp.getNext();
         People next2 = temp.getNext().getNext();
         temp.setNext(next2);
         System.out.println("被干掉了："+next);
         if(next==head){
             head=temp;
         }
         next.setNext(null);


     }
     public void initNumNode(int num){
         if(num<=0){
             return;
         }
         for (int i = 1; i <= num; i++) {
             this.addNode(new People(i,"num"+i));
         }
     }

    /**
     * 约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，
     * 最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
     *
     *
     */
    public void qikefu(){
        this.initNumNode(6);
        People temp=head;
        int i=0;
        while (true){
            if(temp==temp.getNext()){
                break;
            }
            i++;
            People next = temp.getNext();
            if(i==5){
                this.delNode(temp);
                i=0;
            }
            temp=next;
        }

    }




    public static void main(String[] args) {
        /*People xiao = new People(1, "xiao");
        People ming = new People(1, "ming");
        People hui = new People(1, "hui");
        CircleLinkList linkList = new CircleLinkList();
        linkList.addNode(xiao);
        linkList.addNode(ming);
        linkList.addNode(hui);
        linkList.printList();
        System.out.println("开始删除。。。。。。。");
        linkList.delNode(xiao);
        linkList.delNode(ming);
        linkList.delNode(hui);
        linkList.printList();*/
        CircleLinkList linkList = new CircleLinkList();
        //linkList.initNumNode(5);
        //linkList.printList();
        linkList.qikefu();

    }

}