1. package test;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. public class Mytest {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 System.out.println(getPerson(100));
   
10.         }
    
11.        
    
12.         public static int getPerson(int count) {
    
13.                
    
14.                 ArrayList<Integer> as = new ArrayList<>(100);
    
15.                 for (int i = 0;i < count;i++) {
    
16.                         as.add(i + 1);
    
17.                 }
    
18. 
    
19.                 return  getNumber(as, 0);
    
20.                
    
21.         }
    
22.        
    
23.         public static int getNumber(ArrayList<Integer> as,int numberEnd) {
    
24.                 for (int i = 0;i < as.size();i++) {
    
25.                         if ((as.get(i) + numberEnd) % 14 == 0) {
    
26.                                 as.remove(i);
    
27.                         }
    
28.                 }
    
29.                
    
30.                 if (as.size() > 1) {
    
31.                         numberEnd += as.get(as.size() - 1);
    
32.                         getNumber(as,numberEnd);
    
33.                 }
    
34.                
    
35.                 return as.get(0);
    
36.         }
    
37. 
    
38. }
    

复制代码

有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
我使用递归算出来是55,不知道有没有大神来帮忙鉴定一下.

不是92吗?

好像不是55

import java.util.ArrayList;

public class Ezample {
        public static void main(String[] args) {
                ArrayList<Integer> array=new ArrayList<Integer>();
                for(int i=1;i<=100;i++)
                        array.add(i);
                int i=0;
                while(array.size()>1){
                        i=(i+14-1)%array.size();
                        System.out.println("删除"+array.remove(i));
                }
                System.out.println(array.get(0));
        }

}


是92

1. package test;
   
2. 
   
3. public class Person {
   
4.         private int value;
   
5.         private Person previousPerson;
   
6.         private Person nextPerson;
   
7.        
   
8.         public Person() {};
   
9.         public Person(int value) {
   
10.                 this.value = value;
    
11.         }
    
12.         public Person(int value,Person previousPerson) {
    
13.                 this.value = value;
    
14.                 this.previousPerson = previousPerson;
    
15.         }
    
16.         public int getValue() {
    
17.                 return value;
    
18.         }
    
19.         public void setValue(int value) {
    
20.                 this.value = value;
    
21.         }
    
22. 
    
23.         public Person getNextPerson() {
    
24.                 return nextPerson;
    
25.         }
    
26.         public void setNextPerson(Person nextPerson) {
    
27.                 this.nextPerson = nextPerson;
    
28.         }
    
29.         public Person getPreviousPerson() {
    
30.                 return previousPerson;
    
31.         }
    
32.         public void setPreviousPerson(Person previousPerson) {
    
33.                 this.previousPerson = previousPerson;
    
34.         }
    
35.        
    
36.        
    
37. }
    
38. package test;
    
39. 
    
40. 
    
41. public class Mytest {
    
42. 
    
43.         public static void main(String[] args) {
    
44.                
    
45. 
    
46.                 Person first = new Person(1);
    
47.                 Person pre = first;
    
48.                 for (int i = 2;i < 100;i++) {
    
49.                         Person p = new Person(i, pre);
    
50.                         pre.setNextPerson(p);
    
51.                         pre = p;
    
52.                 }
    
53.                 Person last = new Person(100, pre);
    
54.                 pre.setNextPerson(last);
    
55.                
    
56.                 last.setNextPerson(first);
    
57.                 first.setPreviousPerson(last);
    
58.                
    
59.                 Person p = first;
    
60.                 int count = 1;
    
61.                 while (p.getNextPerson() != p) {
    
62.                         if (count % 14 == 0) {
    
63.                                 System.out.println(p.getValue() + "出局");
    
64.                                 Person prePerson = p.getPreviousPerson();
    
65.                                 Person nextPerson = p.getNextPerson();
    
66.                                
    
67.                                 prePerson.setNextPerson(nextPerson);
    
68.                                 nextPerson.setPreviousPerson(prePerson);
    
69.                                 p = nextPerson;
    
70.                                
    
71.                                 count = 1;
    
72.                         } else {
    
73.                                 p = p.getNextPerson();
    
74.                                 count++;
    
75.                         }
    
76.                 }
    
77.                 System.out.println("最后还剩第" + p.getValue() + "人");
    
78. 
    
79.                
    
80.         }
    
81. }

复制代码

谢谢各位提醒，是错误的。
我重新写了一个，仿照链表的方式写的， 答案是92了。

//面向对象的思路去做
public class Test9 {       
        public static void main(String[] args) {
                //调用后面的Personcircle类，有100人
                Personcircle pc = new Personcircle(100);
                //用countNumber计数，等于14的人退出，原来右边的人重新报1
                int countNumber  = 0;
                Person p = pc.first;
                while (pc.count > 1) {
                        countNumber ++;
                        if( countNumber == 14){
                                countNumber = 0;
                                pc.delete(p);
                        }
                p = p.right;
        }
        //打印剩下的一个人的位置       
        System.out.println("原排在第"+(pc.first.id+1)+"位的人留下了。");
        }
}
//person类，属性包括ID，左边人，右边人。
class Person{
        int id;
        Person left;
        Person right;
}
//Personcircle类，，定义属性
class Personcircle{
        int count = 0;
        Person first,last;
        //Personcircle构造方法
        Personcircle(int n){
                for(int i = 0; i < n; i++){
                        add();
                }
        }
        //添加人的方法
        void add(){
                Person p = new Person();
                p.id = count;
                if(count <= 0){
                        //一个人时，最开始，最后的人都是自己
                        first = p;
                        last = p;
                        p.left = p;
                        p.right = p;
                }
                else{
                        //多人时，相互连接构成圈
                        last.right = p;
                        p.left = last;
                        p.right = first;
                        first.left = p;
                        last = p;
                }
                //表明多了一个人
                count ++;
        }
        //删除人的方法
        void delete (Person p){
                if(count <= 0){
                        return;
                }//就一个人，不用删
                else if (count == 1){
                        first = last = null;
                }
                else{
                        //一个人退出后，原来这个人左右两边的人会互相连接
                        p.left.right = p.right;
                        p.right.left = p.left;
                        //如果正好是第一个人被删除的情况
                        if(p == first){
                                first = p.right;
                                }//如果删除的是最后一个人的情况
                        else if (p ==last){
                                last = p.left;
                        }
                }
                //少了一个人
                count --;
        }
｝

我的结果是92
代码如下：
package com.itheima;

import java.util.ArrayList;
public class Test9 {

        public static void main(String[] args) {
                //创建一个集合
                ArrayList<Integer> list = new ArrayList<>();
                //把100人按编号存放到集合中
                for(int i=1; i<=100; i++){
                        list.add(i);
                }
                int count = 1;
                for (int i = 0; list.size() != 1; i++) {
                        //数到一圈的最后一个人,从头开始数
                        if(i  == list.size()){
                                i = 0;
                        }
                        //去掉数14的这个人，并重新开始数数
                        if(count % 14 == 0){
                                list.remove(i--);
                                count = 0;
                        }
                        count++;
                }
                System.out.println(list.get(0));
        }

}

                System.out.println(list.get(0));