约瑟夫斯问题-java版数组解法和链表解法

10个人围成一圈，从1到10编号，从1开始数，数到3或3的倍数的位置，则该位置的人出局，求最后剩下哪一个号？

 

数组解法：

数组存放数组：a[10]存在1到10编号人

数组遍历到尾部又从头遍历：遍历数组--->内循环。设置一个外循环--->使得数组可以从头遍历，而且从1开始的的递增数字。while循环实现

数到3或3的倍数的位置出局：a[i]=0;

退出外部循环的条件：只剩下一人。

具体代码如下：

package algorithm.约瑟夫斯;

public class 数组解法 {

    
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int[] a=new int[10];
        for(int i=0;i<10;i++){
            a[i]=i+1;
        }
        System.out.println("运行到这里");
        int globalNum=0;
        int count=a.length;
        while(count>1){//退出外循环的条件
            for(int i=0;i<a.length;i++){
                
                while(a[i]==0){//跳过已出局的人，globalNum不统计
                    i++;
                }
                globalNum++;
                if(globalNum%3==0){
                    a[i]=0;
                    count--;
                }
            }
        }
        System.out.println();
        for(int i=0;i<a.length;i++){
            if(a[i]!=0)
                System.out.print(a[i]);
        }
    }

}

 单向链表解法（不删除元素）：

package algorithm.约瑟夫斯;

public class 链表解法 {
    
    public class Node{
        public int index;
        public Node next;
        
        public Node(){}
        public Node(int index){
            this.index=index;
            next=null;
        }
        
    }
    
    public static void main(String[] args) {
        链表解法 r=new 链表解法();
        链表解法.Node n=r.new Node();
        链表解法.Node head=r.new Node(1);//链表头节点
        链表解法.Node now=head;
        int len=0;//初始化的时候记录链表长度
        //初始化链表
        for(int i=2;i<=10;i++){
            链表解法.Node node=r.new Node(i);
            //Node是r的成员属性，当new Node(1),又new Node(1)时，
                                  //如果合法，则调用new Node(1)时不知道调用哪个
            
            now.next=node;
            System.out.print(now.index+"、");
            now=now.next;
            if(i==10)
                System.out.println(now.index);
            len++;
        }
        
        链表解法.Node present=head;
        while(present.next!=null){
            System.out.print(present.index+"、");
            present=present.next;
            if(present.next==null){
                present.next=head;
                System.out.println(present.index);
                System.out.println("构建循环链表成功！"+present.index+"的下一个节点值:"+present.next.index);
                break;
            }
        }
        链表解法.Node present1=head;
        int count1=len;
        System.out.println("再次打印链表：");
        while(present1.next!=null&&count1>=1){
            System.out.print(present1.index+"、");
            present1=present1.next;
            if(present1.index==10){
                System.out.println(present1.index);
            }
            count1--;
        }
        //约瑟夫斯问题求解
        链表解法.Node p=head;
        int count=len;
        int global3=0;
        while(true){
            while(p.index!=0){
                global3++;
                System.out.print("["+global3+"、"+p.index+"]");
                if(global3%3==0){
                   System.out.println("global= "+global3+"删除 "+p.index);
                   p.index=0;
                   count--;
                }
                if(count<2){
                    break;
                }
                p=p.next;
            }
            p=p.next;
            if(count<2){
                break;
            }
        }
        
        链表解法.Node present2=head;
        int count2=len;
        
        while(present2.next!=null&&count2>1){
            System.out.print(present2.index+"、");
            present2=present2.next;
            count2--;
        }
    }

}