TNotes.leetcode

Appearance

0169. 多数元素【简单】

0169. 多数元素【简单】 ​

1. 📝 题目描述 ​

给定一个大小为 n 的数组 nums，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：nums = [3,2,3]
输出：3

示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2

提示：

  • n == nums.length
  • 1 <= n <= 5 * 10^4
  • -10^9 <= nums[i] <= 10^9

进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

2. 🎯 s.1 - 排序 ​

js
/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
  return nums.sort((a, b) => a - b)[Math.floor(nums.length / 2)]
}
  • 时间复杂度：O(nlog⁡n)，其中 n 是数组长度，主要消耗在排序上
  • 空间复杂度：O(log⁡n)，排序所需的栈空间

算法思路：

  • 对数组进行排序后，位于中间位置的元素必然是多数元素
  • 因为多数元素出现次数大于 n/2，排序后会占据中间位置

3. 🎯 s.2 - hash-table ​

js
/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
  const len = nums.length,
    map = new Map(),
    majorityCount = Math.floor(nums.length / 2)
  for (let i = 0; i < len; i++) {
    const item = nums[i]
    map.set(item, (map.get(item) || 0) + 1)
    if (map.get(item) > majorityCount) return item
  }
}
  • 时间复杂度：O(n)，其中 n 是数组长度，只需遍历一次数组
  • 空间复杂度：O(n)，需要哈希表存储元素出现次数

算法思路：

  • 使用哈希表统计每个元素的出现次数
  • 当某个元素出现次数超过 n/2 时，直接返回该元素

4. 🎯 s.3 - 分治 ​

img

js
/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
  // 统计数组 nums 的区间 [start, end] 中，num 出现的次数。
  const countInRange = (start, end, num) => {
    let count = 0
    for (let i = start; i <= end; i++) {
      if (nums[i] === num) count++
    }
    return count
  }

  // 获取数组 nums 的区间 [start, end] 中的众数。
  const majorityElementRec = (start, end) => {
    if (start === end) return nums[start]

    // 细分区间，找众数
    let mid = start + Math.floor((end - start) / 2)
    const l_majority = majorityElementRec(start, mid) // 左侧子区间的众数
    const r_majority = majorityElementRec(mid + 1, end) // 右侧子区间的众数
    if (l_majority === r_majority) return l_majority

    // 合并区间，找众数
    const l_count = countInRange(start, end, l_majority)
    const r_count = countInRange(start, end, r_majority)
    return l_count > r_count ? l_majority : r_majority
  }

  return majorityElementRec(0, nums.length - 1)
}
  • 时间复杂度：O(nlog⁡n)，递归树深度为 log⁡n，每层需要 O(n) 时间统计
  • 空间复杂度：O(log⁡n)，递归调用栈的深度

算法思路：

  • 将数组不断二分，分别找出左右子区间的多数元素
  • 如果左右子区间的多数元素相同，直接返回
  • 否则统计两个候选元素在当前区间的出现次数，返回出现次数多的

5. 🎯 s.4 - Boyer-Moore 投票算法 ​

js
/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
  // 使用Boyer-Moore投票算法
  let candidate = nums[0]
  let count = 1

  for (let i = 1; i < nums.length; i++) {
    if (count === 0) {
      candidate = nums[i]
      count = 1
    } else if (nums[i] === candidate) {
      count++
    } else {
      count--
    }
  }

  return candidate
}
  • 时间复杂度：O(n)，其中 n 是数组长度，只需遍历一次数组
  • 空间复杂度：O(1)，只使用了常数级别的额外空间

算法思路：

  • 维护一个候选人 candidate 和计数器 count
  • 遍历数组：如果 count 为 0，更新候选人；相同元素 count++，不同元素 count--
  • 由于多数元素出现次数大于 n/2，最终 candidate 必然是多数元素

Discussions