[Swift]LeetCode229. 求众数 II | Majority Element II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10204770.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times.

Note: The algorithm should run in linear time and in O(1) space.

Example 1:

Input: [3,2,3]
Output: [3]

Example 2:

Input: [1,1,1,3,3,2,2,2]
Output: [1,2]

---

给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。

说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

示例 1:

输入: [3,2,3]
输出: [3]

示例 2:

输入: [1,1,1,3,3,2,2,2]
输出: [1,2]

---

96ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        guard nums.count > 1 else {
            return nums
        }
        
        var majorA = nums[0]
        var countA = 0
        
        var majorB = nums[0]
        var countB = 0
        
        for index in 0...(nums.count-1) {
            if nums[index] == majorA {
                countA += 1
                continue
            } 
            
            if nums[index] == majorB {
                countB += 1
                continue
            }
            
            if countA == 0 {
                majorA = nums[index]
                countA += 1
                continue
            }
            
            if countB == 0 {
                majorB = nums[index]
                countB += 1
                continue
            }

            countA -= 1
            countB -= 1
        }
        
        countA = 0
        countB = 0
        for index in 0...(nums.count - 1) {
            if nums[index] == majorA {
                countA += 1
            } else if nums[index] == majorB {
                countB += 1
            }
        }
                
        var result = [Int]()
        if countA > nums.count/3 {
            result.append(majorA)
        }
        if countB > nums.count/3 {
            result.append(majorB)
        }
        
        return result
    }
}

---

104ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {

        var res = [Int]()
        var cm = 0, cn = 0, m = 0, n = 0
        for a in nums {
            if a == m { cm += 1 }
            else if a == n { cn += 1 }
            else if cm == 0 { m = a; cm = 1}
            else if cn == 0 { n = a; cn = 1 }
            else { cm -= 1; cn -= 1}
        }
        cm = 0; cn = 0
        for a in nums {
            if a == m { cm += 1 }
            else if a == n { cn += 1 }
        }
        if cm > nums.count / 3 {res.append(m)}
        if cn > nums.count / 3 {res.append(n)}
        return res
    }
}

---

112ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        var elems: [Int: Int] = [:]
        for n in nums {
            elems[n, default: 0] +=  1
        }
        return elems.compactMap { key, value in 
            if value > nums.count / 3 { return key } 
            return nil 
        }
    }
}

---

112ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        var dict:[Int : Int] = [Int:Int]()
        for num in nums {
            if let n = dict[num] {
                dict[num] = n + 1
            } else {
                dict[num] = 1
            }
        }
        var r = [Int]()
        let m = nums.count / 3
        for (k,v) in dict {
            if v > m {
              r.append(k)
            }
        }
        return r
    }
}

---

116ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        
        if nums.count == 0 {
            return []
        }
        
        var dict: [Int: Int] = [:]
        var resultList: Set<Int> = []
        let limit = nums.count/3
        
        for number in nums {
            var result = 1
            if let temp = dict[number] {
                result = temp + 1
            }
            dict[number] = result
            
            if result > limit {
                resultList.insert(number)
            }
        }
        
        return Array(resultList)
    }
}

---

124ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        
        if nums.count == 0 {
            return []
        }
        
        var dict: [Int: Int] = [:]
        var resultList: [Int] = []
        let limit = nums.count/3
        
        for number in nums {
            var result = 1
            if let temp = dict[number] {
                result = temp + 1
            }
            dict[number] = result
            
            if result > limit && !resultList.contains(number){
                resultList.append(number)
            }
        }
        
        return resultList
    }
}

---

140ms

class Solution {
    func majorityElement(_ nums: [Int]) -> [Int] {
        var dict = [Int: Int]() 
        var r = [Int]()
        for n in nums {
            dict[n, default: 0] += 1
            if dict.keys.count == 3 {
                for key in dict.keys {
                    dict[key, default: 0] -= 1
                    if dict[key, default: 0] == 0 {
                        dict[key] = nil
                    }
                }
            }
        }
        let c = nums.reduce(into: [Int: Int]()){ $0[$01, default: 0] += 1 }
        return Array(dict.keys).filter { c[$0, default: 0] > nums.count / 3 }
    }
}

---

156ms

class Solution {
   func majorityElement(_ nums: [Int]) -> [Int] {
        var res = [Int:Int].init()
        
        for i in 0..<nums.count {
            if res.keys.contains(nums[i]){
                let value = res[nums[i]]!+1
                res[nums[i]] = value
            }else{
                res[nums[i]] = 1
            }
        }
        
        let dict = res.filter { (arg) -> Bool in
            
            let (_, value) = arg
            return value > nums.count/3
        }
        return Array(dict.keys)
    }
}