数组中出现超过一般的数字

题目描述

面试题39.数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为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大的数字 。

C++实现

方法一：partition思想o(n)

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

//方法一：partition思想，时间复杂度o(n)
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 1
                if(index > middle){
                   end = index-1;    
                   index = partition(numbers,start,end); 
                 }
                else{
                   start = index + 1;
                   index = partition(numbers,start,end);               
                 }
           
            #elif 0    //非零时编译
                //下面的写法无法通过测试，为什么？
                if(index > middle)
                   index = partition(numbers,start,index-1); 
                else
                   index = partition(numbers,index + 1,end);               
            #endif
         }
        int result = numbers[middle];           //这里的只是得到了第middle=n/2大的数字，但总个体是否超过一段还需要判断
        if(!CheckMoreThanHAlf(numbers,length,result))    //此时需要检查result的值的个数是否大于整个数组的一半
            return 0;
        return result;
    }
     //partition快排
    int partition(vector<int> &input,int low,int high){
        int pivot = input[low];   //pivot:枢纽
        //这里的pivotkey也可以是[low,high]区间一个随机数，也可以是三数取中，九数取中，详情见<<大话数据结构>>
        //int pivotkey=input[RandInRange(start,end)];
        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;
       }
      
}; */

方法二：根据数组特点找出时间复杂度为o(n)的算法

如果有符合条件的数字，则它出现的次数比其他所有数字出现的次数和还要多。
在遍历数组时保存两个值：一是数组中一个数字，一是次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所求。然后再判断它是否符合条件即可。

//方法二：根据数组特点找出时间复杂度为o(n)的算法
class Solution{
public:
    int MoreThanHalfNum_Solution(vector<int> numbers){
        if(numbers.empty())
            return 0;
        
        int length = numbers.size();
        int result = numbers[0];
        int times = 0;
        
        for(int i = 1; i < length; ++i){
           //第一步 
            if(result == numbers[i])
                ++times;
            //第二步，可以和第一步交换？
            if(times == 0){
               result = numbers[i];
               times = 1;
             }
            if(result != numbers[i])
                --times;
        }
        if(!CheckMoreThanHAlf(numbers,length,result))    //此时需要检查result的值的个数是否大于整个数组的一半
            return 0;
        return result;
    }
    
    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;
        }
};

方法三：sort排序o(nlogn)的算法(不推荐使用)

数组排序后，如果符合条件的数存在，则一定是数组中间那个数。（比如：1，2，2，2，3；或2，2，2，3，4；或2，3，4，4，4等等）
这种方法虽然容易理解，但由于涉及到快排sort，其时间复杂度为O(NlogN)并非最优；
参考代码如下：

链接：https://www.nowcoder.com/questionTerminal/e8a1b01a2df14cb2b228b30ee6a92163
来源：牛客网

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers)
    {
        // 因为用到了sort，时间复杂度O(NlogN)，并非最优
        if(numbers.empty()) return 0;
         
        sort(numbers.begin(),numbers.end()); // 排序，取数组中间那个数
        int middle = numbers[numbers.size()/2];
         
        int count=0; // 出现次数
        for(int i=0;i<numbers.size();++i)
        {
            if(numbers[i]==middle) ++count;
        }
         
        return (count>numbers.size()/2) ? middle :  0;
    }
};