剑指Offer面试题29（java版）：数组中出现次数超过一半的数字

题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组｛1，2，3，2，2，2，5，4，2｝。由于数字2在数组中出现5次，超过数组长度的一半，因此输出2.

解法一：基于Partition函数的O(n)算法：

我们的算法是受快速排序的算法的启发。在随机快速排序的算法中，我们先在数组中随机的选择一个数字，然后调数组中数字的顺序，使得比选中的数字小数字排在它的左边，比选中的数字大的数字都排在它的右边。比如这个选中的数字的下标刚好是n/2，那么这个数字就是数组中的中位数。如果它的下标大于n/2，那么中位数应该位于它的左边，我们可以接着在它的左边部分的数组中查找。如果它的下标小于n/2，那么中位数应该在它的右边，我们可以接着在它的右边部分中查找。这是一个典型的递归过程。

Java代码实现过程如下：

[java]  view plain  copy

1. /** 
2.  *  
3.  */  
4. package swordForOffer;  
5.   
6. /** 
7.  * @author JInShuangQi 
8.  * 
9.  * 2015年8月8日 
10.  */  
11. public class E29MoreThanHalfNumber {  
12.     //适用partition函数  
13.     public int partition(int[] arr,int left,int right){  
14.         int result = arr[left];  
15.         if(left > right)  
16.             return -1;  
17.           
18.         while(left <right){  
19.             while(left <right && arr[right]>= result){  
20.                 right --;  
21.             }  
22.             arr[left] = arr[right];  
23.             while(left <right && arr[left] <result){  
24.                 left++;  
25.             }  
26.             arr[right] = arr[left];  
27.         }  
28.         arr[left] = result;  
29.         return left;  
30.     }  
31.     public int moreThanHalfNum(int[] arr){  
32.         if(arr.length ==0)  
33.             return -1;  
34.           
35.         int length = arr.length;  
36.         int middle = length >>1;  
37.         int start = 0;  
38.         int end = length -1;  
39.         int index = partition(arr,start,end);  
40.         while(index != middle){  
41.             if(index >middle){  
42.                 end = index - 1;  
43.                 index = partition(arr,start,end);  
44.             }  
45.             else{  
46.                 start = index + 1;  
47.                 index = partition(arr,start,end);  
48.             }  
49.         }  
50.           
51.         int result = arr[middle];  
52.         if(!checkMoreThanHalf(arr,result)){  
53.             result = -1;  
54.         }  
55.         return result;  
56.     }  
57.     //验证是否存在  
58.     public boolean checkMoreThanHalf(int[] arr,int number){  
59.         int times = 0;  
60.         for(int i = 0;i<arr.length;i++){  
61.             if(arr[i] == number)  
62.                 times ++;  
63.         }  
64.         boolean isMoreThanHalf = true;  
65.         if(times *2 <= arr.length){  
66.             isMoreThanHalf = false;  
67.         }  
68.         return isMoreThanHalf;  
69.     }  
70.     public static void main(String[] args){  
71.         int[] arr= {1,2,3,3,2,5,4,2};  
72.         E29MoreThanHalfNumber test = new E29MoreThanHalfNumber();  
73.         System.out.println(test.moreThanHalfNum(arr));  
74.     }  
75. }  

解法二：根据数组的特点找出O(n)的算法：

接下来我们从另外一个角度来解决这个问题。数组中有一个数字出现的次数超过数组长度的一半，也就是说它出现的次数比其他所有数字出现的次数的和还要多。因此我们可以遍历数组的时候保存两个值：一个是数组中的一个数字，一个是次数。当我们遍历到下一个数字的时候，如果下一个数字和我们之前保存的数字相同，则次数加1；如果下一个数字和我们之前保存的数字不同，则次数减1.如果次数为0，我们需要保存下一个数字，并把次数设为1.由于我们要找的数字出现的次数比其他所有数字出现的次数之和还要多，那么要找的数字肯定是最后一次把次数设为1时对应的数字。

[java]  view plain  copy

1. //解法二：  
2.     public int moreThanHalfNum2(int[] arr){  
3.         if(arr.length == 0)  
4.             return -1;  
5.         int result = arr[0];  
6.         int times = 1;  
7.         for(int i = 1;i<arr.length;i++){  
8.             if(times == 0){  
9.                 result = arr[i];  
10.                 times = 1;  
11.             }else if(arr[i] == result)  
12.                 times++;  
13.             else  
14.                 times--;  
15.         }  
16.         if(!checkMoreThanHalf(arr,result))  
17.             result = -1;  
18.         return result;  
19.     }