2021.09.06 - 023.数组中出现次数超过一半的数字

1. 题目

2. 思路

(1) 快速排序

• 当数组有序时，出现次数超过数组长度一半的数字必定是数组中间的那个数字。

(2) 哈希表（半统计）

• 利用哈希表统计每个数字出现的次数。
• 可以边统计边判断每个数字出现的次数是否已经超过了数组长度的一半，超过的话直接返回即可。
• 由于返回的是出现次数超过数组长度一半的数字，因此在统计数组前一半的数字时，目标数字出现的次数必然不可能超过数组长度的一半，因此统计数组前一半的数字时不需要进行判断，以提高效率。

(3) 哈希表（全统计）

• 与(2)的思路基本相同，也可以全部统计完次数后，再找出出现次数超过数组长度一半的数字。
• 在极端情况下，(3)的效率高于(2)。

(4) 分治法

• 基本思想是当一个数字出现次数超过数组长度一半时，那么该数字至少是数组左半部分或右半部分其中一个的众数。
• 若数组长度为 1，则众数是其唯一的值，直接返回即可；若数组长度大于1，则众数是其左右两部分中出现次数更多的众数。

(5) 摩尔投票法

• 如果众数表示总票数+1，其他数字表示总票数-1，则统计整个数组后总票数必定大于0。
• 假设众数是第一个数字，从前向后遍历，如果遇到的数字等于众数，则总票数+1，否则总票数-1。
• 如果在数组前面区间内总票数为0，则后面区间内总票数必然大于0，因此可以重置众数为后面区间的第一个数字，重新开始统计。

3. 代码

import java.util.*;

public class Test {
    public static void main(String[] args) {
        int[] ints = {3, 2, 3};
        Solution1 solution = new Solution1();
        System.out.println(solution.majorityElement(ints));
    }
}

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length / 2];
    }
}

class Solution1 {
    public int majorityElement(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        int minCount = nums.length / 2;
        for (int i = 0; i < minCount; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
        }
        for (int i = minCount; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
            if (map.get(nums[i]) > minCount) {
                return nums[i];
            }
        }
        return nums[0];
    }
}

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

class Solution3 {
    public int majorityElement(int[] nums) {
        return majorityElementRec(nums, 0, nums.length - 1);
    }

    private int majorityElementRec(int[] nums, int low, int high) {
        if (low == high) {
            return nums[low];
        }
        int midIndex = (high - low) / 2 + low;
        int left = majorityElementRec(nums, low, midIndex);
        int right = majorityElementRec(nums, midIndex + 1, high);
        if (left == right) {
            return left;
        }
        int leftCount = countInRange(nums, left, low, high);
        int rightCount = countInRange(nums, right, low, high);
        return leftCount > rightCount ? left : right;
    }

    private int countInRange(int[] nums, int num, int low, int high) {
        int count = 0;
        for (int i = low; i <= high; i++) {
            if (nums[i] == num) {
                count++;
            }
        }
        return count;
    }
}

class Solution4 {
    public int majorityElement(int[] nums) {
        int result = nums[0];
        int count = 0;
        for (int num : nums) {
            if (count == 0) {
                result = num;
            }
            count += num == result ? 1 : -1;
        }
        return result;
    }
}