28.数组中出现次数超过一半的数字

题目

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

思路一

• 如果一个数字a在数组中的次数超过了数组长度的一半，那么如果这个数组有序，
  • 长度为奇数的数组，数组正中间的那个数字 一定等于a。
  • 长度为偶数的数组，数组正中间两个数字后一个数字一定等于a。
• 所以对数组排序之后找到索引nums.size()/2的元素，然后遍历一遍数组，看它的次数是否满足要求。
• 排序的算法的复杂度最好为O(nlgn)。
• 利用快排的思想，第一次排序我们得到mid索引，mid左边的数都不大于mid处的值，mid右边的数都不小于mid处的值。
• 我们判断mid是否等于nums.size()/2。
  • 若大于，则对mid左边进行快排。
  • 若小于，则对mid右边进行快排。
  • 若等于，返回该处的值。
• 所以每次我们都是对半个区间进行排序。计算一下复杂度，O(n+n/2+n/4+…) = O(2n) = O(n)。

代码

class Solution {
private:
    int targetIndex = 0;
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if ( numbers.size() == 0 ) return 0;
         
        targetIndex = numbers.size() / 2;
        int res = helper( numbers, 0, numbers.size()-1 );
         
        if ( !isValid( numbers, res ) )
            res = 0;
         
        return res;
    }
     
    int helper( vector<int>& numbers, int lo, int hi ) {
        int res = 0;
        int mid = partition( numbers, lo, hi );
      
        if ( mid == targetIndex )
            res =  numbers[mid];
        else if ( mid < targetIndex )
            res = helper( numbers, mid+1, hi );
        else if ( mid > targetIndex )
            res = helper( numbers, lo, mid-1 );
         
        return res;
    }
     
    int partition( vector<int>& numbers, int lo, int hi ) {
        int randIndex = lo + rand() % ( hi-lo+1 );
        swap( numbers[lo], numbers[randIndex] );
        int pivot = numbers[lo];
         
        while ( lo < hi ) {
            while ( lo < hi && pivot <= numbers[hi] )
                --hi;
             
            numbers[lo] = numbers[hi];
             
            while ( lo < hi && pivot >= numbers[lo] )
                ++lo;
             
            numbers[hi] = numbers[lo];
        }
         
        numbers[lo] = pivot;
        return lo;
    }
     
    void swap( int& a, int& b ) {
        int temp = a;
        a = b;
        b = temp;
         
        return;
    }
     
    bool isValid( vector<int>& numbers, int target ) {
        int times = 0;
        bool res = false;
         
        for ( auto& n : numbers ) {
            if ( target == n ) ++times;
        }
         
        if ( times >= (numbers.size() >> 1) + 1 )
            res = true;
         
        return res;
    }
};

思路二

• 假如有这么一个圈，里面是数组的元素。两个不同的元素我们就消除掉，假如有一个元素它的数量超过数组长度的一半，这样消除到最后剩下的肯定是这个元素。
  
• 具体的方法是，假如数组为numbers，初始化number=numbers[0], times = 1。
• 从numbers[1]开始遍历数组，如果和number不同，则times减一。
• 如果times为0，则number赋新值。
• 如果和number相同，则times加一。
• 最后number保留的就是抵消后的数，这个数不一定是有效的，要再验证一下才能返回。

代码

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if ( numbers.size() == 0 ) return 0;
        int num = numbers[0];
        int times = 1;
        
        for ( auto& n : numbers ) {
            if ( times == 0 ) {
                times = 1;
                num = n;
            }
            else if ( num == n ) {
                ++times;
            }
            else if ( num != n ) {
                --times;
            }
        }
        
        if ( !isValid( numbers, num ) )
            num = 0;
        
        return num;
    }
    
    bool isValid( vector<int>& numbers, int target ) {
        bool res = false;
        int times = 0;
        
        for ( auto& n : numbers ) {
            if ( target == n )
                ++times;
        }
        
        if ( times - 1 >= numbers.size() >> 1)
            res = true;
        
        return res;
    }
};