169-Majority Element

难度：easy
类别：divide and conquer

1.题目描述

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

You may assume that the array is non-empty and the majority element always exist in the array.

2.算法

先用归并排序将整个数组进行排序，然后对相邻并且相同的数字进行计数，看是否满足count >= n/2,如果满足，则该数即为要找的数。归并排序的时间复杂度是O(nlogn)，而计数部分的时间复杂度是O(n)，所以总的时间复杂度是O(nlogn)

3.代码实现

注：leetcode只要求类的实现，此处包含main函数的实现，便于测试。

#include <iostream>
#include <vector>
using namespace std; 

int majorityElement(vector<int>& nums);
void mergeSort(vector<int>& nums, int min, int max);
void combine(vector<int>& nums, int min, int mid, int max);
int main() {
    int n;
    int value;
    vector<int> data;
    cout << "the size of the array: ";
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> value;
        data.push_back(value);
    }
    cout << majorityElement(data) << endl;
    return 0;
}
int majorityElement(vector<int>& nums) {
    int n = nums.size();
    if (n == 0) return 0;
    if (n == 1) return nums[0];
    mergeSort(nums, 0, n - 1);
    for (int i = 0; i < n; ++i)
        cout << nums[i] <<" ";
    cout <<endl;
    int count = 0;
    for (int i = 0; i < n - 1; ++i) {
        while (nums[i + 1] == nums[i]) {
            count++;
            i++;
        }
        if (count >= n/2) {
            return nums[i-1];
        } else {
            count = 0;
        }
    }
} 
void mergeSort(vector<int>& nums, int min, int max) {
    if (min >= max) return;
    int mid = (min + max)/2;
    mergeSort(nums, min, mid);
    mergeSort(nums, mid+1, max);
    combine(nums, min, mid, max);
}
void combine(vector<int>& nums, int min, int mid, int max) {
    int i = min, j = mid + 1;
    vector<int> temp;
    while (i <= mid && j <= max) {
        if (nums[i] < nums[j]) {
            temp.push_back(nums[i++]);
        } else if (nums[i] > nums[j]) {
            temp.push_back(nums[j++]);
        } else {
            temp.push_back(nums[i++]);
            temp.push_back(nums[j++]);
        }
    } 
    while (i <= mid) {
        temp.push_back(nums[i++]);
    }
    while (j <= max) {
        temp.push_back(nums[j++]);
    }
    for (int i = min; i <= max; ++i) {
        nums[i] = temp[i - min];
    }
}

4.小结

归并排序能够很直接地解决很多问题，并且其时间复杂度不是很高，相比冒泡排序号很多。