《剑指offer》39--数组中出现次数超过一半的数字[C++]

题目描述

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

解题思路

1 Boyer-Moore Majority Vote Algorithm

多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。

使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int len = numbers.size();
        if(len <= 0) return 0;
        int times = 1, result = numbers[0];
        for(int i=1; i<len; ++i) {
            times = (numbers[i] == result) ? times+1 : times-1;
            if(!times) {
                result = numbers[i];
                times = 1;
            }
        }
        times = 0;
        for(int i=0; i<len; ++i) if(result == numbers[i]) times++;
        return (times > len/2) ? result : 0;
    }
};

2 阵地攻守

采用阵地攻守的思想：第一个数字作为第一个士兵，守阵地，count = 1；遇到相同元素，count++；遇到不相同元素，即为敌人，同归于尽,count--；当遇到count为0的情况，又以新的i值作为守阵地的士兵，继续下去，到最后还留在阵地上的士兵，有可能是主元素。再加一次循环，记录这个士兵的个数看是否大于数组一般即可。时间复杂度为O(n)。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int len = numbers.size();
        if(len <= 0) return 0;
        int times = 1, result = numbers[0];
        for(int i=1; i<len; ++i) {
            if(numbers[i] == result) times++;
            else times--;
            if(!times) {
                result = numbers[++i];
                times = 1;
            }
        }
        times = 0;
        for(int i=0; i<len; ++i) if(result == numbers[i]) times++;
        if(times*2<=len) result = 0;
        return result;
    }
};

3 Partiton思想

快速排序求中位数，时间复杂度为O(n)。

class Solution {
public:
    int Partition(vector<int>& input, int begin, int end) {
        int pivot = input[begin];
        while(begin<end) {
            while(begin<end && pivot<=input[end]) end--;
            input[begin] = input[end];
            while(begin<end && pivot>=input[begin]) begin++;
            input[end] = input[begin];
        }
        input[begin] = pivot;
        return begin;
    }
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int length = numbers.size();
        if (numbers.empty() || length<0) return 0;
        int begin = 0, end = length - 1, middle = length >> 1;
        int index = 0, cnt = 0;; 
        while (begin<end) {
            index = Partition(numbers, begin, end);
            if (index == middle) break;
            else if (index > middle) end = index - 1; //则值在左边部分的数组。
            else begin = index + 1;//则值在右边部分的数组。
        }
        for (int i = 0; i < length; ++i)//检查该值是否超过数组长度的一半
            if (numbers[index] == numbers[i]) cnt++;
        if (cnt * 2 > length) return numbers[index];
        return 0;
    }
};

4 排序找中位数

时间复杂度为O(nlog(n))

class Solution {
public:
    int MoreThanHalfNum_Solution(vectornumbers) {
        int len = numbers.size();
        if(len <= 0) return 0;
        int result = numbers[0], times = 1;
        for(int i=1; i<len> numbers) {
        int length = numbers.size();
        if (length == 0) return 0;
        sort(numbers.begin(), numbers.end());
        int max_num = 0, num = 0, val = numbers[0];
        for (int i = 0; i < length; i++) {
            if (val == numbers[i]) num++;
            else {
                max_num = num > max_num ? num : max_num;
                if (max_num > length/2) return val;
                val = numbers[i];
                num = 1;
            }
        }
        max_num = num > max_num ? num : max_num;
        if (max_num > length / 2) return val;
        else return 0;
    }
};
//再来一个
class Solution {
public: // 因为用到了sort，时间复杂度O(NlogN)，并非最优
    int MoreThanHalfNum_Solution(vectornumbers) {
        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>numbers.size()/2) ? middle :  0;
    }
};