【剑指Offer】数组中出现次数超过一半的数字（快排O(NlogN) ，抵消法O(N) , hashmapO(N) ）

本文链接：https://blog.csdn.net/X1qgirl/article/details/107524854

题目描述

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

思路

快排O(NlogN)，O(1)

正常思路可以先排序，再取中间值，中间值就是数组中出现次数超过一半的数字。
先快排，然后从中间数开始，双指针往两边遍历，记录和中间数连续相同的个数，一旦断掉，直接break。

时间复杂度O(NlogN)
空间复杂度O(1)

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        //快排再去判断数组中间那个数字是否为众数，时间复杂度O(NlogN)
        if(numbers.size()==0)
            return 0;
        //快排，时间复杂度O(NlogN)
        sort(numbers.begin(), numbers.end());
        
        int anws = numbers[numbers.size()/2], cnt = 1;
        int i=numbers.size()/2-1, j=numbers.size()/2+1;
        while( i>=0 && j<numbers.size() ){
            if( anws != numbers[i] && anws != numbers[j] ){
                break;
            }
            if( anws == numbers[i] ){
                i--;
                cnt++;
            }
            if( anws == numbers[j] ){
                j++;
                cnt++;
            }
        }
        if( cnt>numbers.size()/2 )
            return anws;
        else
            return 0;
    }
};

试探抵消法O(N)，O(1)

用anws记录上一次访问的值，count表明当前值出现的次数，如果下一个值和当前值相同那么count++；如果不同count–，减到0的时候就要更换新的anws值了，因为如果存在超过数组长度一半的值，那么最后anws一定会是该值。可以这样理解，count的自加和自减就是在描述一种抵消关系，由于超过一半的出现次数，导致最后的anws一定会是该值。（这种方法的时间复杂度自然会小些）

首先第一个for循环结束后得到的num是什么？如果这个数组中存在个数大于数组长度一半的数，那么这个num一定是这个数，因为数组中所有不是num的数，一定会被这个数覆盖，所以最后得到的数是num。
但是！！如果这个数组中根本不存在个数大于数组长度一半的数，那么这个num就是一个不确定的值，这也是为什么找出num之后，还要再做一次循环验证这个数出现的个数是不是大于数组长度一半的原因。

时间复杂度O(N)
空间复杂度O(1)

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        //快排再去判断数组中间那个数字是否为众数，时间复杂度O(NlogN)
        if(numbers.size()==0)
            return 0;
        //试探法：如果这个数组中存在个数大于数组长度一半的数，那么这个num一定是这个数，
        //因为数组中所有不是num的数，一定会被这个数覆盖，所以最后得到的数是num。
        int anws = numbers[0], cnt = 1;
        for(int i=1; i<numbers.size(); i++){
            if( numbers[i]==anws ){
                cnt++;
            }else{
                cnt--;
                if( cnt==0 ){
                    anws = numbers[i];
                    cnt = 1;
                }
            }
        }
        //但是！！如果这个数组中根本不存在个数大于数组长度一半的数，那么这个num就是一个不确定的值，
        //这也是为什么找出num之后，还要再做一次循环验证这个数出现的个数是不是大于数组长度一半的原因。
        cnt = 0;
        for( int i=0; i<numbers.size(); i++ ){
            if(numbers[i]==anws)
                cnt++;
        }
        if( cnt > numbers.size()/2 )
            return anws;
        return 0;
    }
};

//leetcode
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        //抵消法。每次都记录上一个数字及其次数1，当遍历到下一个数时，如果相同则次数++；如果次数不同，则次数--，次数减为0时就将当前这个数更换为被记录的数且次数为1。题设说一定有一个数字的次数超一半，那么最后被记录的这个数一定就是它。
        if( nums.size() == 0)
            return -1;

        int anws = nums[0], count = 1;
        for(int i=0; i<nums.size(); i++){
            if( nums[i]==anws ){
                count++;
            }else{
                count--;
                if( count==0 ){
                    anws = nums[i];
                    count = 1;
                }
            }
        }
        return anws;
    }
};

hashmap

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int,int> unmap;
        for(int i=0; i<nums.size(); i++){
            unmap[nums[i]]++;
            if(unmap[nums[i]] > nums.size()/2){
                return nums[i];
            }
        }
        return 0;
    }
};