[Swift]LeetCode347. 前K个高频元素 | Top K Frequent Elements

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

Given a non-empty array of integers, return the k most frequent elements.

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]

Example 2:

Input: nums = [1], k = 1
Output: [1]

Note:

• You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
• Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

---

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

说明：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
• 你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。

---

推荐1（助力理解优先队列）：

public struct Heap<T> {
    public var nodes = [T]()
    private var orderCriteria: (T, T) -> Bool
    
    public init(sort: @escaping (T, T) -> Bool) {
        orderCriteria = sort
    }
    
    public init(array: [T], sort: @escaping (T, T) -> Bool) {
        self.orderCriteria = sort
        configureHeap(from: array)
    }
    
    public var isEmpty: Bool {
        return nodes.isEmpty
    }
    
    public var count: Int {
        return nodes.count
    }
    
    public mutating func configureHeap(from array: [T]) {
        nodes = array
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    public mutating func reset() {
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    @inline(__always) internal func parentIndex(ofIndex index: Int) -> Int {
        return (index - 1) / 2
    }
    
    @inline(__always) internal func leftChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 1
    }
    
    @inline(__always) internal func rightChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 2
    }
    
    public func peek() -> T? {
        return nodes.first
    }
    
    internal mutating func shiftUp(_ index: Int) {
        var childIndex = index
        let child = nodes[childIndex]
        var parentIndex = self.parentIndex(ofIndex: index)
        while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
            nodes[childIndex] = nodes[parentIndex]
            childIndex = parentIndex
            parentIndex = self.parentIndex(ofIndex: childIndex)
        }
        nodes[childIndex] = child
    }
    
    internal mutating func shiftDown(from index: Int, until endIndex: Int) {
        let leftChildIndex = self.leftChildIndex(ofIndex: index)
        let rightChildIndex = self.rightChildIndex(ofIndex: index)
        
        var first = index
        if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
            first = leftChildIndex
        }
        if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
            first = rightChildIndex
        }
        if first == index {
            return
        }
        nodes.swapAt(index, first)
        shiftDown(from: first, until: endIndex)
    }
    
    internal mutating func shiftDown(_ index: Int) {
        shiftDown(from: index, until: nodes.count)
    }
    
    public mutating func insert(_ value: T) {
        nodes.append(value)
        shiftUp(nodes.count - 1)
    }
    
    public mutating func insert<S: Sequence>(_ sequence:S) where S.Iterator.Element == T {
        for value in sequence {
            insert(value)
        }
    }
    
    public mutating func replace(index i: Int, value: T) {
        guard i < nodes.count else {
            return
        }
        remove(at: i)
        insert(value)
    }
    
    @discardableResult
    public mutating func remove() -> T? {
        guard !nodes.isEmpty else {
            return nil
        }
        if nodes.count == 1 {
            return nodes.removeLast()
        } else {
            let value = nodes[0]
            nodes[0] = nodes.removeLast()
            shiftDown(0)
            return value
        }
    }
    
    @discardableResult
    public mutating func remove(at index: Int) -> T? {
        guard index < nodes.count else { return nil}
        let size = nodes.count - 1
        if index != size {
            nodes.swapAt(index, size)
            shiftDown(from: index,  until: size)
            shiftUp(index)
        }
        return nodes.removeLast()
    }
    
    public mutating func sort() -> [T] {
        for i in stride(from: self.nodes.count - 1, to: 0, by: -1) {
            nodes.swapAt(0, i)
            shiftDown(from: 0, until: i)
        }
        return nodes
    }

}


class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        var heap = Heap<(Int, Int)>.init { (f, s) -> Bool in
            return f.1 < s.1
        }
        var dict = [Int: Int]()
        for i in nums {
            dict[i] = (dict[i] ?? 0) + 1
        }
        
        for i in dict {
            heap.insert(i)
            if heap.count > k {
                heap.remove()
            }
        }
        var array = [Int]()
        while heap.count > 0 {
            array.append(heap.peek()!.0)
            heap.remove()
        }
        return array.reversed()
    }
}

---

 推荐2（助力理解优先队列）：

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        
        let numCount = self.countNums(nums)
        
        var heap = MinHeap<NumberCount>([])
        
        for n in numCount{
            heap.add(n)
            if heap.count > k{
                heap.poll()
            }
        }
        
        var result = [Int]()
        
        while heap.peek() != nil{
            let currentN = heap.poll()
            result.append(currentN.n)
        }
        
        result.reverse()
        
        return result
    }
    
    func countNums(_ nums:[Int]) -> [NumberCount]{
        
        var dict = [Int:Int]()
        for n in nums{
            var count = dict[n] ?? 0
            count += 1
            dict[n] = count
        }
        
        var result = [NumberCount]()
        
        for(k,v) in dict{
            let newN = NumberCount(k, v)
            result.append(newN)
        }
        
        return result
    }
}

class MinHeap<T:Comparable>{
    
    var data:[T]
    
    init(_ data:[T]){
        self.data = data
    }
    
    func parent(_ index:Int) -> T{
        return self.data[self.parentIndex(index)]
    }
    
    func leftChild(_ index:Int) -> T{
        return self.data[self.leftChildIndex(index)]
    }
    
    func rightChild(_ index:Int) -> T{
        return self.data[self.rightChildIndex(index)]
    }
    
    func parentIndex(_ index:Int) -> Int{
        return (index - 1) / 2
    }
    
    func leftChildIndex(_ index:Int) -> Int{
        return index * 2 + 1
    }
    
    func rightChildIndex(_ index:Int) -> Int{
        return index * 2 + 2
    }
    
    func hasParent(_ index:Int) -> Bool{
        return self.parentIndex(index) >= 0
    }
    
    func hasLeftChild(_ index:Int) -> Bool{
        return self.leftChildIndex(index) < self.count
    }
    
    func hasRightChild(_ index:Int) -> Bool{
        return self.rightChildIndex(index) < self.count
    }
    
    func add(_ item:T){
        self.data.append(item)
        if self.data.count > 1{
            self.heapifyUp()
        }
    }
    
    func poll() -> T{
        let first = self.data[0]
        self.data[0] = self.data[self.count - 1]
        self.data.removeLast()
        self.heapifyDown()
        return first
    }
    
    func peek() -> T?{
        if self.count == 0{
            return nil
        }
        return self.data[0]
    }
    
    func heapifyUp(){
        var currentIndex = self.count - 1
        while hasParent(currentIndex) && parent(currentIndex) > self.data[currentIndex]{
            self.data.swapAt(currentIndex, parentIndex(currentIndex))
            currentIndex = parentIndex(currentIndex)
        }
    }
    
    func heapifyDown(){
        var currentIndex = 0
        while hasLeftChild(currentIndex){
            var smallerIndex = leftChildIndex(currentIndex)
            if hasRightChild(currentIndex) && rightChild(currentIndex) < leftChild(currentIndex){
                smallerIndex = rightChildIndex(currentIndex)
            }
            if self.data[currentIndex] > self.data[smallerIndex]{
                self.data.swapAt(currentIndex, smallerIndex)
                currentIndex = smallerIndex
            }else{
                break
            }
        }
    }
    
    var count:Int{
        return self.data.count
    }
}

class NumberCount : Comparable{
    
    let n:Int
    var count:Int = 0
    
    init(_ n:Int, _ count:Int){
        self.n = n
        self.count = count
    }
    
    static func < (lhs:NumberCount, rhs:NumberCount) -> Bool{
        return lhs.count < rhs.count
    }
    
    static func == (lhs:NumberCount, rhs:NumberCount) -> Bool{
        return lhs.count == rhs.count
    }
}

---

推荐3（助力理解优先队列）：

class Solution {
    struct MyTuple: Comparable {
        var first, second: Int
        static func < (lhs: MyTuple, rhs: MyTuple) -> Bool {
            return lhs.second < rhs.second
        }
    }
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        var dict: [Int: Int] = [:]
        for num in nums {
            if let val = dict[num] {
                dict[num] = val + 1
            }
            else {
                dict[num] = 1
            }
        }

        var heap: Heap<MyTuple> = Heap(isMaxHeap: false)
        for (key, value) in dict {
            if heap.count < k {
                heap.insert(MyTuple(first: key, second: value))
            }
            else {
                if value > heap.top()!.second {
                    heap.replace(MyTuple(first: key, second: value))
                }
            }
        }

        var result: [Int] = []
        while !heap.isEmpty() {
            result.append(heap.delete()!.first)
        }

        return result.reversed()
    }
}

struct Heap<T: Comparable> {
    fileprivate var nums: [T?] = [Optional.none]
    fileprivate var isMaxHeap: Bool = true
    public var count: Int {
        return nums.count - 1
    }
    
    public init(_ arr: [T] = [], isMaxHeap: Bool = true) {
        self.isMaxHeap = isMaxHeap
        self.nums.append(contentsOf: arr)
        for i in stride(from: count/2, to: 0, by: -1) {
            isMaxHeap ? heapifyDown(i, &nums, >) : heapifyDown(i, &nums, <)
        }
    }
    
    // 是否为空
    public func isEmpty() -> Bool {
        return count == 0
    }
    
    // 插入元素
    public mutating func insert(_ num: T) {
        nums.append(num)
        heapify(count, &nums) { a, b in
            return self.isMaxHeap ? a > b : a < b
        }
    }
    
    // 删除堆顶元素
    public mutating func delete() -> T? {
        guard !isEmpty() else {
            return nil
        }
        //将堆顶元素与最后一个元素交换
        nums.swapAt(1, count)
        let res = nums.removeLast()
        heapifyDown(1, &nums) { a, b in
            return self.isMaxHeap ? a > b : a < b
        }
        return res
    }
    
    // 堆顶元素
    public func top() -> T? {
        guard !isEmpty() else {
            return nil
        }
        return nums[1]
    }
    
    // 替换堆顶元素
    public mutating func replace(_ num: T) {
        nums[1] = num
        isMaxHeap ? heapifyDown(1, &nums, >) : heapifyDown(1, &nums, <)
    }
    
    // 堆化(自下向上)
    private func heapify(_ location: Int, _ nums: inout [T?],  _ compare: (T, T) -> Bool) {
        var loc = location
        while loc/2 > 0 && compare(nums[loc]!, nums[loc/2]!) {
            nums.swapAt(loc, loc/2)
            loc /= 2
        }
    }
    
    // 堆化(自上而下)
    fileprivate func heapifyDown(_ location: Int, _ nums: inout [T?], _ compare: (T, T) -> Bool) {
        var loc = location
        while loc * 2 <= count {
            var swapLoc = loc
            if compare(nums[loc * 2]!, nums[loc]!) {
                swapLoc = loc * 2
            }
            if loc * 2 + 1 <= count && compare(nums[loc * 2 + 1]!, nums[swapLoc]!) {
                swapLoc = loc * 2 + 1
            }
            if loc == swapLoc {
                break
            }
            nums.swapAt(loc, swapLoc)
            loc = swapLoc
        }
    }
}

---

 92ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        if nums == [] { return [] }
        var map = [Int : Int]()
        
        // O(n)
        for i in 0...nums.count-1 {
            if let m = map[nums[i]] {
                // O(1)?
                map.updateValue(m + 1, forKey: nums[i])
            }
            else{
                map[nums[i]] = 1
            }
        }
        
        // sortedBy is O(n log n)
        var mapVal = map.sorted(by: { $0.value > $1.value })
        var res = [Int]()
        
        // O(k)
        for i in 0...k-1 {
            res.append(mapVal[i].key)
        }
        
        return res
    }
}

---

96ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {

        var countDict = [Int: Int]()
        
        for n in nums {
            countDict[n, default: 0] += 1
        }
        
        var sorted = countDict.sorted { $0.value > $1.value }
        
        return sorted[0..<k].map { $0.key }
    }
}

---

100ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        guard nums.count > 1 else { return nums }
        
        var hashMap: [Int: Int] = [:]
        
        for i in nums {
            hashMap[i, default: 0] +=  1 
        }
        
        let sortedPairs = hashMap.sorted{ $0.value > $1.value}
        
        let sortedKeys = sortedPairs.map{ $0.key }
     
        return Array(sortedKeys.prefix(k))
    }
}

---

104ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        
        var res = [Int]()
        var map = [Int:Int]()
        if k > nums.count { return res }
        
        for num in nums {
            map[num] = map[num] == nil ? 1 : map[num]! + 1
        }
        
        let sortedArray = map.sorted{ $0.value > $1.value }
        var count = 0
        for (key, value) in sortedArray {
        if(count >= k) { break }
            res.append(key)
            count += 1 
        }
        return res
    }
}

---

108ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        let counter: [Int: Int] = nums.reduce(into: [Int: Int]()) { $0[$1, default: 0] += 1}
        let sortedKeys = counter.keys.sorted { counter[$0]! >= counter[$1]!}
        return [Int](sortedKeys[0..<k])
    }
}

---

112ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        var countMap: [Int: Int] = [:]
        for num in nums {
            countMap[num, default: 0] += 1
        }
        
        var sortedList: [[Int]] = Array(repeating: [], count: nums.count + 1)
        for (key, value) in countMap {
            sortedList[value].append(key) 
        }
        
        var result: [Int] = []
        var i = nums.count
        while i > 0 && result.count < k {
            result.append(contentsOf: sortedList[i])
            
            i -= 1
        }
        return result
    }
}

---

120ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
    var dict = [Int:Int]()
    nums.forEach {
        dict[$0] = (dict[$0] == nil ? 0 : dict[$0]! ) + 1
    }
 
    return dict.sorted(by:  { $0.value > $1.value } )[0..<k].map({$0.key})
}
}

---

124ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        var countMap:[Int:Int] = [:]
        for num in nums {
            countMap[num] = countMap[num] == nil ? 1 : countMap[num]! + 1
        }
        var vals = Array(countMap.keys)
        vals.sort {
            return countMap[$0]! > countMap[$1]!
        }
        return Array(vals[0..<k])
    }
}

---

148ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        //  input: [1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4,]
        //  buckets: [[], [], [2], [1, 4, 3], [], [], [], [], [], [], [], []]
        // list of numbers whose frequency is at buckets[i]
        var buckets = Array(repeating: [Int](), count: nums.count + 1)
        
        // key: number      value: number of times it appears in the array
        var freqMap = [Int: Int]()
        
        for num in nums {
            if let times = freqMap[num] {
                freqMap[num] = 1 + times
            } else {
                freqMap[num] = 1
            }
        }

        for key in freqMap.keys {
            let frequency = freqMap[key]!
            buckets[frequency].append(key)
        }
        
        print(buckets)

        // we go backwards because the end contains the highest frequencies
        var result = [Int]()
        for i in stride(from: buckets.count - 1, to: 0, by: -1) {
            if !buckets[i].isEmpty && result.count < k {
                result.append(contentsOf: buckets[i])
            }
        }
        return result
    }
}

---

156ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        var temp = (Dictionary(nums.map { ($0, 1) }, uniquingKeysWith: +)).sorted { (a, b) -> Bool in
            return a.value>b.value
            }.compactMap { (a) -> Int? in
                return a.key
        }
        return Array(temp[0..<k])
    }
}

---

160ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        
        // Map for value -> # occurences
        var dict = [Int: Int]()
        for value in nums {
            dict[value] = (dict[value] ?? 0) + 1
        }
        
        print(dict)
        
        // Index maps to frequency the value appears in array
        var buckets = [[Int]](repeating: [], count: nums.count + 1)
        for (key, value) in dict {
            buckets[value].append(key)
        }
        
        print(buckets)
        
        var kMostFrequent = [Int]()
        var currMost = 0
        
        for subArr in buckets.reversed() where currMost < k {
            for value in subArr where currMost < k {
                kMostFrequent.append(value)
                currMost += 1
            }
        }
        
        return kMostFrequent
    }
}

---

164ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        if k < 0 || k > nums.count { return [] }
        var dict = [Int: Int]()
        nums.forEach {
            dict[$0] = (dict[$0] ?? 0) + 1
        }
        
        var pairs = dict.map { $0 }
        quickSelect(&pairs, 0, pairs.count - 1, k)
        return Array(pairs.prefix(k).map { $0.key })
    }
    
    func quickSelect(_ pairs: inout [(key: Int, value: Int)], _ start: Int, _ end: Int, _ k: Int) {
        
        if start == end {
            return 
        }
        
        let pivot = pairs[end]
        var left = start
        for i in start..<end {
            if pairs[i].value >= pivot.value {
                pairs.swapAt(left, i)
                left += 1
            }
        }
        pairs.swapAt(left, end)
        
        if left + 1 == k {
            return 
        } else if left + 1 > k {
            quickSelect(&pairs, start, end - 1, k)
        } else {
            quickSelect(&pairs, left + 1, end, k)
        }
    }
}

---

172ms

class Solution {
    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
        guard k >= 1 && k <= nums.count else {
            return []
        }
        var numCounts = [Int: Int]()
        for num in nums {
            if let numCount = numCounts[num] {
                numCounts[num] = numCount + 1
            } else {
                numCounts[num] = 1
            }
        }
        let numInfos = numCounts.sorted {
            $0.1 >= $1.1
        }
        return Array(numInfos[0 ..< k]).map {
            $0.0
        }
    }
}