2020-08-17

169. 多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [3,2,3]
输出: 3
示例 2:
输入: [2,2,1,1,1,2,2]
输出: 2
摩尔投票法思路
候选人(cand_num)初始化为nums[0]，票数count初始化为1。
当遇到与cand_num相同的数，则票数count = count + 1，否则票数count = count - 1。
当票数count为0时，更换候选人，并将票数count重置为1。
遍历完数组后，cand_num即为最终答案。
为何这行得通呢？
投票法是遇到相同的则票数 + 1，遇到不同的则票数 - 1。
且“多数元素”的个数> ⌊ n/2 ⌋，其余元素的个数总和<= ⌊ n/2 ⌋。
因此“多数元素”的个数 - 其余元素的个数总和 的结果 肯定 >= 1。
这就相当于每个“多数元素”和其他元素 两两相互抵消，抵消到最后肯定还剩余至少1个“多数元素”。
无论数组是1 2 1 2 1，亦或是1 2 2 1 1，总能得到正确的候选人。

class Solution {
    public int majorityElement(int[] nums) {
        int cand_num = nums[0], count = 1;
        for (int i = 1; i < nums.length; ++i) {
            if (cand_num == nums[i])
                ++count;
            else if (--count == 0) {
                cand_num = nums[i];
                count = 1;
            }
        }
        return cand_num;
    }
}

229. 求众数 II

给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。
示例 1:
输入: [3,2,3]
输出: [3]
示例 2:
输入: [1,1,1,3,3,2,2,2]
输出: [1,2]

 func majorityElement(_ nums: [Int]) -> [Int] {
        var result = [Int]()
        if nums.count < 1 {return result}
        if nums.count == 1 {
            result.append(nums[0])
            return result;
        }
        var cand1 = nums[0], cand2 = nums[0]
        var count1 = 0, count2 = 0
        // 配对阶段
        for num in nums {
            
            if cand1 == num {
                count1 += 1
                continue
            }
            if cand2 == num {
                count2 += 1
                continue
            }
            
            if count1 == 0 {
                cand1 = num
                count1 += 1
                continue
            }
            
            if count2 == 0 {
                cand2 = num
                count2 += 1
                continue
            }
            
            count1 -= 1
            count2 -= 1
        }
        
        // 计数阶段
        count2 = 0; count1 = 0
        for num in nums {
            if cand1 == num {
                count1 += 1
            }else if cand2 == num {
                count2 += 1
            }
        }
        
        if count1 > nums.count / 3 {
            result.append(cand1)
        }
        if count2 > nums.count / 3 {
            result.append(cand2)
        }
        
        return result
    }

53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

private static void HeapSort(int[] nums, int k) {
	// 安全判断
	if (nums == null || nums.Length == 0) return;
	// 构建大顶堆
	BuildHeap(nums);
	// 每一次重构顶堆，我们都会把当前的最大值给“沉”到堆尾，即排序完一个当前最大值
    // 而最后一个当前最大值就不需要排序了(即最小值)，因为前面排完，最后一个就自动确定了
    // 所以要排完整个长度为 n 的序列，需要重构顶堆 n - 1 次

	int len = nums.Length - 1;
	//我们只需遍历 K 次就可以把得到第 K 个最大元素
	for (int i = nums.Length - 1; i > nums.Length - 1 - k; i--) {
		// 交换堆顶与堆尾，把当前最大值“沉”到最下面
        Swap(nums, 0, i);
        // 因为每重构一次，当前最大值都会被“沉”到 当前的最后一层
        // 所以每重构一次，要 len--，防止最大值又被重构到最顶层
        Heapify(nums, 0, len--);
	}
}

private static void BuildHeap(int[] nums) {
	int start = nums.Length / 2 - 1;
	for (int i = start; i >= 0; i--) {
		Heapify(nums, start, nums.Length);
	}
}

private static void Heapify(int[] nums, int i, int len) {
	int left = 2 * i + 1;
	int right = 2 * i + 2;
	int largestIndex = i;
	if (left < len && nums[left] > nums[largestIndex]) {
		 largestIndex = left;
	}
	if (right < len && nums[right] > nums[largestIndex]) {
		largestIndex = right;
	}
	if (largestIndex != i) {
		Swap(nums, largestIndex, i);
		Heapify(nums, largestIndex, len);
	}
}

private static void Swap(int[] nums, int i, int j) {
	nums[i] ^= nums[j];
	nums[j] ^= nums[i];
	nums[i] ^= nums[j];
}