逢三退一（双向回环链表算法）

 方法一

1. /* 用常规方法实现（双向回环链表算法）
2.  * 
3.  * 逢三退一：一个头和尾相连的圆形数字队列，从第一个开始数，数到三，
4.  * 就把三的那个去掉，然后接着数，如此循环，逢三退一。
5.  * 直到最后一个为止，求最后一个是数字队列中的第几个？
6.  */
7. public class Cout3Quit
8. {
9.     public static void main(String[] args)
10.     {
11.         boolean[] arr = new boolean[500]; // 创建一个布尔型数组
12.         int contNum = 0; // 数数，计算数了多少个,数到3就退1个
13.         int index = 0; // 第几个位置，数到的位置
15.         int arrlength = arr.length; // 数字队列还有多少个
17.         for (int i = 0; i < arr.length; i++)
18.         {
19.             arr[i] = true; // 把数组的值得全部置为true
20.         }
22.         while (arrlength > 1) // 留下最后一个
23.         {
24.             if (arr[index] == true)
25.             {
26.                 contNum++; // 从0开始数
28.                 if (contNum == 2) // 从0开始的，数到2就是第三个数字了
29.                 {
30.                     arr[index] = false; // 数到第三个数，把它的值变为false
31.                     arrlength--; // 数组长度减去1
32.                     contNum = 0; // 重新数数
33.                 }
34.             }
36.             index++; // 每判断一个，加1
37.             if (index == arr.length) // 判断是否到了最后的数字，到了,重新从0开始
38.             {
39.                 index = 0;
40.             }
41.         }
43.         // 打印数组中有true值的那个下标值，即最后那个是第几个
44.         for (int j = 0; j < arr.length; j++)
45.         {
46.             if (arr[j] == true)
47.             {
48.                 System.out.println(j);
49.             }
50.         }
52.     }
54. }

方法二

2. /*
3.  * 用面向对象方法实现（双向回环链表算法）
4.  *  
5.  * 逢三退一：一个头和尾相连的圆形数字队列，从第一个开始数，数到三，
6.  * 就把三的那个去掉，然后接着数，如此循环，逢三退一。
7.  * 直到最后一个为止，求最后一个是数字队列中的第几个？
8.  */
10. public class Count3Quit2
11. {
12.     public static void main(String[] args)
13.     {
14.         KidCircle kc = new KidCircle(500);
16.         int num = 0;
18.         Kid k = kc.first;   //从第一个开始数数
20.         while (kc.count > 1)
21.         {
22.             num++;   //数数
24.             if (num == 2)  // 从0开始的，数到2就是第三个数字了
25.             {
26.                 kc.delete(k);  //删除当前的k
27.                 num = 0;       //重新数数
28.             }
30.             k = k.right;  //k右孩子赋给k
31.         }
33.         System.out.println(kc.first.id); // 打印最后的一个孩子的id
35.     }
36. }
38. class Kid
39. {
40.     int id = 0; // 孩子号码
41.     Kid left; // 左边的孩子
42.     Kid right; // 右边的孩子
43. }
45. class KidCircle
46. {
47.     int count = 0;
48.     Kid first;
49.     Kid last;
51.     // 构造函数，构造n个孩子围成的圈
52.     public KidCircle(int n)
53.     {
54.         for (int i = 0; i < n; i++)
55.         {
56.             add(); // 调用add方法，循环一次增加一个孩子
57.         }
58.     }
60.     // 添加孩子
61.     public void add()
62.     {
63.         Kid k = new Kid();
64.         k.id = count;
66.         if (count <= 0)
67.         {
68.             first = k; // 只有一个孩子
69.             last = k;
70.             k.left = k;
71.             k.right = k;
72.         }
73.         else
74.         {
75.             last.right = k; // 从最后的节点开始，k成为last的右边孩子
76.             k.left = last; // last成为k的左边孩子
77.             k.right = first; // k成为first的右边孩子
78.             first.left = k; // k成为first的左边孩子
79.             last = k; // 这时候k变成了最后一个
80.         }
82.         count++;
83.     }
85.     // 删除孩子
86.     public void delete(Kid k)
87.     {
88.         if (count <= 0) // 没有孩子
89.         {
90.             return;
91.         }
92.         else if (count == 1) // 只剩一个孩子
93.         {
94.             first = last = null;
95.         }
96.         else
97.         {
98.             k.left.right = k.right; // k的右孩子成为 k的左孩子 的右边孩子
99.             k.right.left = k.left; // k的左孩子成为 k的右孩子 的左边孩子
101.             if (k == first) // 如果k是第一个孩子first
102.             {
103.                 first = k.right;
104.             }
105.             else if (k == last) // 如果k是第一个孩子last
106.             {
107.                 last = k.left;
108.             }
109.         }
111.         count--;
112.     }
113. }