剑指Offer——数组中出现次数超过一半的数字

题目描述

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

方法一

最先想到的是对数组记性排序，然后遍历数组找出出现次数 超过数组长度的一半的数。该方法的时间复杂度就是排序用的时间，即最快的排序算法的时间复杂度O(nlogn)。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if( numbers.empty() )
            return 0;
        sort(numbers.begin(),numbers.end());
        int i = 0;
        int size = numbers.size();
        for( int j=0;j<size;j++ )
        {
            if( numbers[j] != numbers[i] )
                i = j;
            if( j-i+1 > size/2 )
                return numbers[j];
        }
        return 0;
    }
};

如果 一个数字出现的次数超过数组长度的一半，那么在排序后，这个数字应该位于数组的中间位置，所以可以在对数组进行排序后，直接取中间位置的数字，但需要考虑不存在出现的次数超过数组长度的一半的数字的情况，所以在取中间位置的数字后，需要遍历一遍统计其出现次数进行检验。（改进：也可以利用快排思想，利用递归找到处于数组中间位置的数字，而不需要对整个数组排序排序完）

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.empty())
            return 0;
        sort(numbers.begin(), numbers.end());
         
        int size = (int)numbers.size();
        int num = numbers[size/2];
        int count = 0;
        for(int i=0; i<size; ++i)
        {
            if(num == numbers[i])
                ++count;
        }
        if(count > size/2)
            return  num;
        else
            return  0;
    }
};

方法二

利用map记录每个数字以及数字出现的次数，其中key为数组元素值，value为此数出现的次数。遍历一遍数组，统计每个数出现的次数，判断有没有出现次数超过数组长度的一半的值。此时的时间复杂度为 O(n)，空间复杂度为O(n)。个人比较喜欢这种方法，实现起来简单，不过空间复杂度大一些。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if( numbers.empty() )
            return 0;
        int size = numbers.size();
        unordered_map<int, int> record;
        for( int i=0;i<size;i++ )
        {
            record[numbers[i]]++;
            if( record[numbers[i]] > size/2 )
                return numbers[i];
        }
        return 0;
    }
};

方法三

        如果一个数字出现的次数超过数组长度的一半，所以这个数字出现的次数比其他数出现的次数的总和还多。考虑每次删除两个不同的数，那么在剩下的数中，出现的次数仍然超过总数的一般，不断重复该过程，排除掉其他的数，最终找到那个出现次数超过一半的数字。这个方法的时间复杂度是O(N)，空间复杂度是O(1)。

       换个思路，这个可以通过计数实现，而不是真正物理删除。在遍历数组的过程中，保存两个值，一个是数组中数字，一个是出现次数。当遍历到下一个数字时，如果这个数字跟之前保存的数字相同，则次数加1，如果不同，则次数减1。如果次数为0，则保存下一个数字并把次数设置为1，由于我们要找的数字出现的次数比其他所有数字出现的次数之和还要多，如果存在，那么要找的数字肯定是最后一次把次数设为1时对应的数字。

注意：找到数字后需要检验其正确性。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if( numbers.empty() )
            return 0;
        int times = 0;
        int res = 0;
        int size = numbers.size();
        for( int i=0;i<size;i++ )
        {
            if( times == 0 )
            {
                res = numbers[i];
                times ++;
            }
            else if( numbers[i] == res )
                times++;
            else
                times--;
        }
        times = 0;
        for( int i=0;i<size;i++ )
            if( numbers[i] == res )
                times++;
        if( times > size/2 )
            return res;
        else
            return 0;
    }
};