LeetCode-169. Majority Element

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.

求一个数组中个数超过一半的元素。
所以简单的办法是使用Hash。

仔细想想，这个题目等价于求经过排序的这个数组的中位数。所以我们可以直接对其排序然后取中间值。O(nlogn)
同时中位数等价于求第[n / 2]大(小)的数字。
所以也可以使用针对 kth 的快速选择算法。O(n)

---

针对这个题目，其实还有一个多数投票算法。

该算法的思想：

每次都找出一对不同的元素，从数组中删掉，直到数组为空或只有一种元素。 不难证明，如果存在元素 e 出现次数超过半数，那么数组中最后剩下的就只有e。

当然，最后剩下的元素也可能并没有出现半数以上。比如说数组是[1, 2, 3]，最后剩下的3显然只出现了1次，并不到半数。排除这种false positive情况的方法也很简单，只要保存下原始数组，最后扫描一遍验证一下就可以了。

算法流程：设置一个计数器 count 和保存当前最多元素的变量 candidate

• 如果count == 0，则将 candidate 的值设置为数组的当前元素，将 count 赋值为1；
• 反之，如果 candidate 和当前数组元素值相同，则 count++，反之 count–；
  重复上述两步，直到扫描完数组。

判断 candidate 是不是所选元素：
count 赋值为0，再次从头扫描数组，如果数组元素值与 candidate 的值相同则count++，直到扫描完数组为止。
如果此时 count 的值大于等于 n / 2，则返回 candidate 的值，否则返回-1。

package solutions._169;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * 169. Majority Element
 */
public class Solution {

    // Hash
    public int majorityElement1(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            if (map.containsKey(num)) {
                map.put(num, map.get(num) + 1);
                if (map.get(num) > (nums.length / 2)) {
                    return num;
                }
            } else {
                map.put(num, 1);
            }
        }
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() > (nums.length / 2)) {
                return entry.getKey();
            }
        }
        return 0;
    }

    // 中位数
    public int majorityElement2(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length / 2];
    }

    // 多数投票算法
    public int majorityElement3(int[] nums) {
        int count = 1;
        int candidate = nums[0];
        for (int i = 1; i < nums.length; ++i) {
            if (count == 0) {
                candidate = nums[i];
                count = 1;
            } else if (candidate == nums[i]) {
                ++count;
            } else {
                count--;
            }
        }
        return candidate;
    }

    private int partition(int[] arr, int left, int right) {
        int pivot = arr[left];
        while (left < right) {
            while (left < right && arr[right] >= pivot) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;
    }

    // 快速选择算法
    private int QuickSelect(int[] arr, int left, int right, int k) {
        if (left < right) {
            int pivotPos = partition(arr, left, right);
            if (pivotPos == k - 1) {
                return arr[pivotPos];
            } else if (pivotPos > k - 1) {
                return QuickSelect(arr, left, pivotPos - 1, k);
            } else {
                return QuickSelect(arr, pivotPos + 1, right, k);
            }
        }
        return arr[left];
    }

    // 选择第
    public int majorityElement4(int[] nums) {
        int k = nums.length / 2;
        return QuickSelect(nums, 0, nums.length - 1, 2);
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] arr = {1, 4, 3, 4, 4};
//        System.out.println(solution.majorityElement1(arr));
//        System.out.println(solution.majorityElement2(arr));
//        System.out.println(solution.majorityElement3(arr));
        System.out.println(solution.majorityElement4(arr));
    }
}

参考：
http://blog.csdn.net/kimixuchen/article/details/52787307