剑指offer面试题[29]-数组中出现次数超过一半的数字

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

分析思路：

      如果这个题目是排好序的数组，那么我们就很容易统计出每个数字出现的次数。题目给出的数组没有说是排好序的，因此我们需要先给它排序。排序的时间复杂度是O(nlogn)。最直观的算法通常不是面试官满意的算法，我们需要找出更快的算法。

****其中一种思路是：基于Partition函数的O(n)算法

       我们回到题目本身分析，就会发现前面的思路并没有考虑到数组的特性：数组中有一个数字出现的次数超过了数组长度的一半。如果我把这个数组排序，那么排序之后位于数组中间的数字一定就是那个出现次数超过数组一半的数字。也就是说，这个数字就是统计学上的中位数，即长度为n的数组中第n/2的数字。我们有成熟的O(n)的算法得到数组中任意第K大的数字。

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

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int length=numbers.size(); 
        if(numbers.empty()||length<0)
            return 0;
        int middle=length>>1;
        int start=0;
        int end=length-1;
        //int index=partition(numbers,length,start,end);       
        int index=partition(numbers,start,end);               
        while(index!=middle)
         { 
            if(index>middle)
             {
               end=index-1;
               index=partition(numbers,start,end);  
             }
            else
             {
               start=index+1;
               index=partition(numbers,start,end);                
             }
         }
        int result=numbers[middle];           //这里的只是得到了第middle=n/2大的数字，但总个体是否超过一段还需要判断
        if(!CheckMoreThanHAlf(numbers,length,result))    //此时需要检查result的值的个数是否大于整个数组的一半
            return 0;
        return result;
    }
    
    
    int partition(vector<int> input,int low,int high)
      {
        int pivotkey=input[low];   //pivot:枢纽
        //这里的pivotkey也可以是[low,high]区间一个随机数，也可以是三数取中，九数取中，详情见<<大话数据结构>>
        //int pivotkey=input[RandInRange(start,end)];
        while(low<high)
          {
            while(low<high&&pivotkey<input[high])
                high--;
            swap(&input[low],&input[high]);
            while(low<high&&pivotkey>=input[low])
                low++;
            swap(&input[low],&input[high]);
          }  
        return low;
      }
    
    /*这个partition是优化了不必要的交换，将swap用赋值替换
    int partition(vector<int> &input, int begin, int end)
     {
       int low = begin;
       int high = end;
       int pivot = input[low];
       while (low < high)
        {
          while (low < high&&pivot <= input[high])
             high--;
          input[low] = input[high];         //优化不必要的替换
          while (low < high&&pivot >= input[low])
             low++;
          input[high] = input[low];         //优化不必要的替换
        }
          input[low] = pivot;
          return low;
      }
    */
    
    bool CheckMoreThanHAlf(vector<int> numbers,int length,int result)    //检查result的值的个数是否大于整个数组的一半
        {
           int times=0;
           for(int i=0;i<length;++i)
             {
                if(numbers[i]==result)
                    times++;
             }
           bool isMoreThanHalf=true;
           if(times*2<=length)
               isMoreThanHalf=false;
           return isMoreThanHalf;
        }
    
    void swap(int *a,int *b)   //交换两个数
        {
           int temp;
           temp=*a;
           *a=*b;
           *b=temp;
        }
    /*下面的partition是剑指offer上的实现，考虑的很详情，但是没有上面的好理解
    int RandInRange(int a,int b)    //产生一个[a,b]范围内的随机整数
        {
           int c;
           c=a+rand()%(b-a+1);
           return c;
        }
    
    int partition(vector<int>& data,int length,int start,int end)    //partition函数是为了找出数组中第K大的数字 
       {
          if(data.empty()||length<0||start<0||end>=length)
              return 0;  //throw new std::exception("Invakid Parameters");
          int index=RandInRange(start,end);          
          swap(&data[index],&data[end]);   
          int small=start-1;
          for(index=start;index<end;++index)
            {
               if(data[index]<data[end])
                 {
                   ++small;
                   if(small!=index)
                        swap(&data[index],&data[small]); 
                 }
            }
           ++small;
           swap(&data[small],&data[end]); 

           return small;
       }
       */
};