Discuss：www.cnblogs.com/grandyang/p…
Given an array nums of size n, return the majority element.
The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.
Example 1:
Input: nums = [3,2,3]
Output: 3
Example 2:
Input: nums = [2,2,1,1,1,2,2]
Output: 2
Constraints:
-
n == nums.length
-
1 <= n <= 5 * 104
-
-231 <= nums[i] <= 231 - 1
解法一：
暴力求解，两层循环计数。时间复杂度 O(N^2)
class Solution {
fun majorityElement(nums: IntArray): Int {
val n = nums.size / 2
var result = 0
kotlin.run run@{
nums.forEach { x ->
var count = 0
nums.forEach { y ->
if (x == y) {
count++
}
if (count > n) {
result = x
return@run
}
}
}
}
return result
}
}
解法二：
先把数组从小到大排序，然后遍历数组，统计相同元素出现的次数，如果大于 nums.size/2 就返回。时间复杂度是 0(NlogN)。
class Solution {
fun majorityElement(nums: IntArray): Int {
val n = nums.size / 2
var result = 0
Arrays.sort(nums)
var temp = nums[0]
var count = 0
kotlin.run run@{
nums.forEach {
if (it == temp) {
count++
} else {
temp = it
count = 1
}
if (count > n) {
result = it
return@run
}
}
}
return result
}
}
还有一个 trick 的写法，无需遍历数组，因为题目保证一定存在 Majority Element 一定存在，所以将数组排序之后，数组的第 nums.size/2 的元素就是 Majority Element。
class Solution {
fun majorityElement(nums: IntArray): Int {
Arrays.sort(nums)
return nums[nums.size / 2]
}
}
解法三：
利用 Map 记录每个元素的出现次数，然后遍历 Map，找到出现次数大于 nums.size/2 的元素返回即可。时间复杂度 O(N)。
class Solution {
fun majorityElement(nums: IntArray): Int {
val n = nums.size / 2
var result = 0
val map = mutableMapOf<Int, Int>()
for (num in nums) {
if (map.containsKey(num)) {
map[num] = map.getValue(num) + 1
} else {
map[num] = 1
}
}
for (mutableEntry in map) {
if (mutableEntry.value > n) {
result = mutableEntry.key
break
}
}
return result
}
}
解法四：
这是道求大多数的问题，有很多种解法，其中我感觉比较好的有两种，一种是用哈希表，这种方法需要 O(n) 的时间和空间，另一种是用一种叫摩尔投票法 Moore Voting，需要 O(n) 的时间和 O(1) 的空间，比前一种方法更好。这种投票法先将第一个数字假设为过半数，然后把计数器设为1，比较下一个数和此数是否相等，若相等则计数器加一，反之减一。然后看此时计数器的值，若为零，则将下一个值设为候选过半数。以此类推直到遍历完整个数组，当前候选过半数即为该数组的过半数。不仔细弄懂摩尔投票法的精髓的话，过一阵子还是会忘记的，首先要明确的是这个方法是有前提的，就是数组中一定要有过半数的存在才能使用，下面来看本算法的思路，这是一种先假设候选者，然后再进行验证的算法。现将数组中的第一个数假设为过半数，然后进行统计其出现的次数，如果遇到同样的数，则计数器自增1，否则计数器自减1，如果计数器减到了0，则更换下一个数字为候选者。这是一个很巧妙的设定，也是本算法的精髓所在，为啥遇到不同的要计数器减1呢，为啥减到0了又要更换候选者呢？首先是有那个强大的前提存在，一定会有一个出现超过半数的数字存在，那么如果计数器减到0了话，说明目前不是候选者数字的个数已经跟候选者的出现个数相同了，那么这个候选者已经很 weak，不一定能出现超过半数，此时选择更换当前的候选者。那有可能你会有疑问，那万一后面又大量的出现了之前的候选者怎么办，不需要担心，如果之前的候选者在后面大量出现的话，其又会重新变为候选者，直到最终验证成为正确的过半数，时间复杂度O(N)，代码如下：
class Solution {
fun majorityElement(nums: IntArray): Int {
var curMajor = nums[0]
var count = 0
nums.forEach {
if (curMajor == it) {
count++
} else {
count--
}
if (count == 0) {
curMajor = it
count = 1
}
}
return curMajor
}
}
解法五：
下面这种解法利用到了位操作 Bit Manipulation 来解，将这个大多数按位来建立，从0到31位，每次统计下数组中该位上0和1的个数，如果1多，那么将结果 result 中该位变为1，最后累加出来的 result 就是过半数了，相当赞的方法，参见代码如下：
class Solution {
fun majorityElement(nums: IntArray): Int {
val n = nums.size / 2
var result = 0
for (i in 0 until 32) {
var ones = 0
var zeros = 0
for (num in nums) {
if (ones > n || zeros > n) {
break
}
if (num.and((1.shl(i))) != 0) {
ones++
} else {
zeros++
}
}
if (ones > zeros) {
result = result.or(1.shl(i))
}
}
return result
}
}
