Coursera Algorithms week3 快速排序 练习测验: Decimal dominants（寻找出现次数大于n/10的元素）

题目原文：

Decimal dominants. Given an array with n keys, design an algorithm to find all values that occur more than  n/10 times. The expected running time of your algorithm should be linear.

分析：

直观上将n个元素遍历一遍，并记录每个元素出现的次数就可以实现，虽然时间复杂度是O(n)，但是空间复杂度却高达n，这肯定不是该题目的初衷。对于n个元素来说，出现n/10次的元素最多有10个，那么出现超过n/10次的元素最多不超过9个，所以需要9个额外空间auxs就能满足需求。

这9个辅助空间aux怎么使用呢？可采用俄罗斯方块的消去一行的思路。只不过这里消去一行的情况是该行中元素各不相同。

1. 遍历数组array中的每个元素array[i]

2. 如果array[i]在aux中存在，将其在aux中的计数+1

3. 如果array[i]在aux中不存在

　　3.1 如果aux未满，将其放入aux中，并记录其个数为1

　　3.2 如果aux已满，将aux中已经存在的各个元素的计数都减去1，直到某个元素的个数变成0，将array[i]放入aux中该位置处，并记录其个数为1

4. 出现次数超过n/10的元素在array遍历完了之后，还会继续存在于aux中，当然aux中可存在着位于array后方但出现次数不满足要求的元素。这时只需要遍历aux的同时再遍历一遍array，记录aux中各个元素在array中出现的次数，将其中出现次数真正超过n/10的元素找出来即可。

 package week3;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import edu.princeton.cs.algs4.StdRandom;
 
 public class ElemsMoreThanNDivTenTimes {
 
     private class Element{//辅助空间元素定义，用来记录元素值及其出现次数
         public int element;
         public int count;
         public Element(int e,int c){
             this.element = e;
             this.count = c;
         }
     };
     private Element[] elems = new Element[9]; //申请9个辅助空间
 
     public ArrayList<Integer> findElements(int[] arrays){
         int n = arrays.length;
         for(int k=0;k<9;k++){
             elems[k] = new Element(0,0); //辅助空间初始化
         }
         for(int i=0;i<n;i++){
             int index = findIndex(arrays[i]);
             if(index >= 0)
                 elems[index].count ++;
             else
                 addToElems(arrays[i]);
         }
         return verifyElems(arrays);
     }
 
     private int findIndex(int e){
         for(int k = 0; k<9;k++){
             if(elems[k].element == e)
                 return k;
             else if(elems[k].count == 0){
                 elems[k].element = e;
                 return k;
             }
         }
         return -1;
     }
     private void addToElems(int e){
         boolean insertFlag = false;
         while(!insertFlag){
             for(int k=0; k<9;k++){
                 elems[k].count --;
                 if(elems[k].count <= 0){
                     elems[k].element = e;
                     elems[k].count = 1;
                     insertFlag = true;
                     break;
                 }
             }
         }
     }
     private ArrayList<Integer> verifyElems(int[] arrays){
         int n = arrays.length;
         for(int k = 0; k< 9; k++){
             elems[k].count = 0;
             for(int i = 0; i< n;i++){
                 if(arrays[i]==elems[k].element)
                     elems[k].count++;
             }
         }
         ArrayList<Integer> elemList = new ArrayList<Integer>();
         for(int k = 0; k< 9; k++){
             if(elems[k].count > n/10)
                 elemList.add(elems[k].element);
         }
         return elemList;
     }
 
     public static void main(String[] args){
         int n = 20;
         int[] array = new int[n];
         for(int i=0;i<n;i++){
             array[i] = StdRandom.uniform(n);
         }
         System.out.println(Arrays.toString(array));
         ElemsMoreThanNDivTenTimes elems = new ElemsMoreThanNDivTenTimes();
         ArrayList<Integer> elemList =  elems.findElements(array);
         System.out.println(elemList.toString());
     }
 }