查找多数元素

问题

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

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

• 示例：

  1. 示例 1：
     输入：nums = [3,2,3]
     输出：3
  2. 示例 2：
     输入：nums = [2,2,1,1,1,2,2]
     输出：2

• 提示：

  n == nums.length
  1 <= n <= 5 * 104
  -109 <= nums[i] <= 109

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

• 来源

  来源：力扣（LeetCode）
  链接：https://leetcode.cn/problems/majority-element

---

解法一：排序后统计连续出现的次数

// 方法一：首先对数组排序，如果是多数元素，则连续出现的次数至少大于n/2次。
const numsValidate1 = (arr) => {
    const len = arr.length
    const minCount = Math.ceil(len/2) - 1  // 因为连续出现的次数至少大于n/2次，ceil是向上取整，例如有5个元素，除2后就是3。减1是因为要比的元素已经有了，需要比较n/2向上取整次，例如[1,1,1,2,2,2,2]，要比4次，要比的元素为1，被比的元素为1，1，2，用1和这3个被比的元素去比较，其实4个元素真正比了3次
    arr = arr.sort()
    for(var i=0; i<arr.length - minCount; i++){  // 循环arr.length - minCount次是为了防止数组溢出，当在比较第i次是， i+j次已经进行了比较
        var count = minCount  // 每次都要比较Math.ceil(len/2) - 1次
        for(var j=1; j<=minCount; j++){
            if(arr[i] === arr[i+j]){
                count-- // 当要比的元素和被比的元素相同时，让count--
            }
        }
        if(count === 0) return arr[i]  // 当count等于零时，证明要比的元素至少出现Math.ceil(len/2) - 1次，此时该元素为多数元素
    }
}

// console.log(numsValidate([2,2,1,1,1,2,2]));

解法二：排序取中间元素

// 方法二：首先对数组排序，因为连续出现的次数至少大于n/2次，那么最中间的数一定是多数元素
// const numsValidate2 = (arr) => {
//     arr = arr.sort((a,b) => a-b)
//     return arr[Math.ceil(arr.length / 2) - 1]  // 减1是因为数组的索引是从零开始，其实可以不用减1，直接用Math.floor()向下取整，但是我觉得向上取整更容易理解，因为连续出现的次数至少大于n/2次，所以应该向上取整
// }
// console.log(numsValidate1([1]));

解法三：使用Map统计次数后比较

// 方法三：使用Map，遍历数组存入到Map中，如果Map中有该元素，让键值对的值加1，没有就等于1然后和数组长度的二分之一比较
// const numsValidate3 = (arr) => {
//     const len = arr.length / 2
//     const map = new Map()
//     for(var i=0; i<arr.length; i++){
//         map.set(arr[i], map.get(arr[i]) ? map.get(arr[i])+1 : 1)
//         if(map.get(arr[i]) > len) return arr[i]
//     }
// }
// console.log(numsValidate3([2,2,1,1,1,2,2]));

解法四：分治法

// 概念：在计算机科学中，分治法（英语：Divide and conquer）是建基于多项分支递归的一种很重要的算法范型。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

// const numsValidate4 = (arr) => {
//     // 统计数组 arr 的区间 [start, end] 中，num 出现的次数。
//   const countInRange = (start, end, num) => {
//     let count = 0;
//     for (let i = start; i <= end; i++) {
//       if (arr[i] === num) count++;
//     }
//     return count;
//   };

//   // 获取数组 arr 的区间 [start, end] 中的众数。
//   const majorityElementRec = (start, end) => {
//     if (start === end) return arr[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, arr.length - 1);
// };
// console.log(numsValidate4([2,2,1]));