1. /** 
    2.  * 有一个数组a[N]，要求每隔两个数删掉一个数，到末尾则又循环到开头继续进行 
    3.  * 求最后一个被删掉的数的原始下标位置 
    4.  *  
    5.  *  例如，一个数组：{0, 1, 2, 3, 4, 5, 6, 7}  
    6.  *  0->1->2(第一遍，删除)->3->4->5(第一遍，删除)->6->7-> 
    7.  *  0(第二遍，删除)->1->2(已删除)->3->4(第二遍，删除)->5(已删除)->6->7... 
    8.  *  循环直到数组中最后一个元素被删除 
    9.  *   
    10.  *  当然，这里并未真正删除元素，只是用标志位表示已经被删除 
    11.  *  
    12.  * @author Wll 
    13.  * 
    14.  */  
    15. public class DeleteEveryTwo {  
    16.     public static void main(String[] args) {  
    17.         int index = getLastDeletedIndex(8);  
    18.         System.out.println("The last index deleted is " + index);  
    19.     }  
    20.   
    21.     /** 
    22.      *  
    23.      * @param a 
    24.      *            数组长度 
    25.      * @return 最后被删除的数的原始下标 
    26.      */  
    27.     public static int getLastDeletedIndex(int len) {  
    28.         if (len <= 0) { // 如果数组长度不满足要求则返回 -1  
    29.             return -1;  
    30.         }  
    31.   
    32.         int[] arr = new int[len];  
    33.         for (int i = 0; i < len; i++) { // 初始化每个元素的值为当前下标  
    34.             arr[i] = len;  
    35.         }  
    36.   
    37.         final int DELFLAG = len + 1; // 删除标志位  
    38.         int currentSize = len; // 记录数组当前有效长度（即未被置为删除标志的元素个数），最后变为 0  
    39.         final int STEP = 2; // 步长  
    40.         int count = 0; // 步长计数  
    41.         int lastDelIndex = 0; // 记录最后被删除的元素的下标  
    42.         int i = 0; // 循环下标  
    43.   
    44.         while (currentSize != 0) {  
    45.             if (arr[i] != DELFLAG) { // 判读当前元素是否等于删除标志  
    46.                 if (count++ == STEP) { // 当步长计数满足步长则  
    47.                     arr[i] = DELFLAG; // 将元素置为删除标志位  
    48.                     lastDelIndex = i; // 记录该处下标  
    49.                     currentSize--; // 有效数组长度减 1  
    50.                     count = 0; // 步长计数归零  
    51.                     System.out.println("Deleted index is " + i % len);  
    52.                 }  
    53.             }  
    54.             i = (i + 1) % len; // 下标取余实现循环下标  
    55.         }  
    56.         return lastDelIndex;  
    57.     }  
    58. }