[九度][何海涛] 数组中出现次数超过一半的数字

题目描述：

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

 

输入：

每个测试案例包括2行：

第一行输入一个整数n（1<=n<=100000），表示数组中元素的个数。

第二行输入n个整数，表示数组中的每个元素，这n个整数的范围是[1,1000000000]。

 

输出：

对应每个测试案例，输出出现的次数超过数组长度的一半的数，如果没有输出-1。

 

样例输入：

9
1 2 3 2 2 2 5 4 2

样例输出：

2


这道题可以分两种方法做。方法1：类似于消除原理，既然某个数字大于长度的一半，那么我们就遍历数组，如果两个数不相等则消除，最后剩下的数就是我们要的。当然如果不存在这样的数，这是不行的。所以最后要再遍历一遍验证这个数的出现次数是否大于数组的一半。

#include <iostream>
using namespace std;

bool check(int num[], int key, int n)
{
    int count = 0;
    for(int i = 0; i < n; i++)
        count += (key == num[i]);

    return 2 * count > n;
}

int main()
{
    int firstCount = 0;
    int secondCount = 0;
    int firstNum;
    int secondNum;
    int num[100000];

    int n;
    while(cin >> n)
    {
        firstCount = 0;
        secondCount = 0;
        for(int i = 0; i < n; i++)
        {
            cin >> num[i];
            if (firstCount > 0 && num[i] == firstNum)
            {
                firstCount++;
            }
            else if (secondCount > 0 && num[i] == secondNum)
            {
                secondCount++;
            }
            else if (firstCount == 0)
            {
                firstNum = num[i];
                firstCount = 1;
            }
            else if (secondCount == 0)
            {
                secondNum = num[i];
                secondCount = 1;
            }
            else
            {
                int minCount = min(secondCount, firstCount);
                secondCount -= minCount;
                firstCount -= minCount;
                if (secondCount == 0)
                {
                    secondNum = num[i];
                    secondCount = 1;
                }
                else
                {
                    firstNum = num[i];
                    firstCount = 1;
                }
            }
        }

        int minV = min(firstCount, secondCount);
        firstCount -= minV;
        secondCount -= minV;

        if (firstCount > 0)
        {
            if (check(num, firstNum, n))
                cout << firstNum << endl;
            else
                cout << -1 << endl;
        }
        else if (secondCount > 0)
        {
            if (check(num, secondNum, n))
                cout << secondNum << endl;
            else
                cout << -1 << endl;
        }
        else
            cout << -1 << endl;
    }
}

方法2：用qsort的partition的方法找出第k大数，k就是数组中间的数，对于n为偶数是中间两个的任意一个数，奇数的话就只有一个。那么，因为数的个数超过一半，那么中间那个数肯定是超过一半的那个数，否则这个数就不存在了。最后遍历一遍数组来验证一下。partition的平摊复杂度为O(n)。最后算法总体复杂度O(n)

#include <iostream>
#include <ctime>
#include <cmath>
#include <algorithm>
using namespace std;

void partition(int num[], int left, int right, int k)
{
    if (left >= right)
        return;

    int randNum = left + (rand() % (right - left + 1));

    int t = num[left];
    num[left] = num[randNum];
    num[randNum] = t;

    int i = left;
    int j = right;

    int key = num[left];

    while(i <= j)
    {
        if (num[i] <= key)
            i++;
        else
        {
            int t = num[j];
            num[j] = num[i];
            num[i] = t;

            j--;
        }
    }

    num[left] = num[j];
    num[j] = key;

    if (j == k)
        return;
    else
    {
        partition(num, left, j - 1, k);
        partition(num, j + 1, right, k);
    }
}

int main()
{
    int n;
    int num[100000];

    while(cin >> n)
    {
        for(int i = 0; i < n; i++)
            cin >> num[i];

        srand(time(NULL));
        partition(num, 0, n - 1, n / 2);

        int key = num[n / 2];

        int count = 0;
        for(int i = 0; i < n; i++)
            count += (key == num[i]);

        if (2 * count > n)
            cout << key << endl;
        else
            cout << -1 << endl;
    }
}