[Swift]实现优先队列PriorityQueue

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

助力理解优先队列：LeetCode347. 前K个高频元素 | Top K Frequent Elements

      你是否在刷题的过程中遇到这样的情况？在一个循环中插入数组元素，同时需要对数组进行排序，在当前循环中按优先级获取数组的元素进行相关操作，如果将插入和排序分为两个步骤，很可能得到这样的结果：Time Limit Exceeded[超出时间限制]。这就需要有一种数据结构：在插入操作的过程中，元素已被放置在正确的排序位置上，插入元素后后可以直接按优先级获取数组的元素。优先队列PriorityQueue可以实现这种功能。在优先队列中，元素被赋予优先级。最大值或最小值都可以被定义为优先级。当优先队列的元素并非简单的Int类型，而是多维数组或元组等其他数据结构，可以自定义优先级。

      在C++、C#、Java等一些经典编程语言的工具包中，工程师已经帮你创建PriorityQueue的数据结构，只需要简单导入调用，立马可以一顿操作猛如虎。但是，如果你正在使用类似于Swift这种2014年发布的编程语言，刷题的时候，你发现有些数据结构需要自己实施。数据结构万变不离其宗，追本溯源，请即刻上车，并且系好安全带。现在发车，先从源头回顾一些概念。

1、满二叉树。

定义：一个二叉树的所有非叶子节点都存在左右孩子，并且所有叶子节点都在同一层级上。

2、完全二叉树。

定义：对一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号为从1到n。如果这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同，则这个二叉树为完全二叉树。

3、二叉堆

二叉堆本质上是一种完全二叉树。

最大堆：任何一个父节点的值，都大于等于它左、右孩子节点的值。

最小堆：任何一个父节点的值，都小于等于它左、右孩子节点的值。

堆顶：二叉堆的根节点叫堆顶。

最大堆的堆顶是整个堆中的最大元素，

最小堆的堆顶是整个堆中的最小元素。

4、二叉堆的操作

（1）插入节点：上浮。

二叉堆插入节点时，插入位置是完全二叉树的最后一个位置。

此时，比较新节点和其父节点，是否符合最大堆或最小堆的定义。

若不符合则和父节点交换位置，即上浮。

重复这样的过程，直到不需要交换位置。

（2）删除节点：下沉。

二叉堆删除节点的过程和插入节点的过程正好相反。

删除的是堆顶的节点。删除堆顶后，堆顶空缺。

为了继续维持完全二叉树的结构，

把堆的最后一个节点，替补到堆顶空缺的位置。

让堆顶节点和其左右孩子进行比较，是否符合最大堆或最小堆的定义。

若不符合则和左右孩子交换位置，即下沉。

两种二叉堆的比较方法：

　　最小堆：取左右孩子节点中最小的一个交换下沉。

　　最大堆：取左右孩子节点中最大的一个交换下沉。

（3）构建二叉堆：

把一个无序的完全二叉树调整为二叉堆，

本质是：让所有非叶子节点依次执行下沉操作。

5、二叉堆操作的时间复杂度

二叉堆的插入操作是单一节点的上浮。

二叉堆的删除操作是单一节点的下沉。

这两个操作的平均交换次数都是堆高的一半。

二叉堆操作的时间复杂度：

插入：O(logn)

删除：O(logn)

构建：O(n)

6、二叉堆的物理存储。

二叉堆虽然是一个完全二叉树，但是其用顺序存储。

二叉堆的所有节点都存储在数组当中。

假设父节点的下标是p,则：

左孩子下标：2p + 1

右孩子下标：2p + 2

铺垫一大堆，我想你已经想要关闭本界面。

但这些都是优先队列知其然知其所以然，现在开始编代码。

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。最高的优先级，即是堆顶节点。

根据二叉堆具有最大堆和最小堆。相应的优先队列也有两种：

最大优先队列：由最大堆实现，当前最大元素优先出队。

最小优先队列：由最小堆实现，当前最小元素优先出队。

Talk is cheap.Show me your code.废话少说，放码过来。

简单的PriorityQueue示例：

/*
 Created by 山青咏芝 on 2019/6/2
*/
//Mark:最大优先队列
class PriorityQueue
{
    //用于存储优先队列数据
    var array:[Int]
    //优先队列数据大小
    var size:Int
    
    //初始化优先队列
    init()
    {
        //数组初始长度32
        self.array = [Int](repeating: 0, count: 32)
        //队列初始大小为0
        self.size = 0
    }
    
    //MARK:队列扩容为原来的2倍
    func resize()
    {
        self.array += self.array
    }
    
    //Mark:入队
    func  enQueue(_ key:Int)
    {
        //队列长度超出范围，扩容
        if size >= array.count
        {
            resize()
        }
        array[size] = key;
        size += 1
        //上浮
        upAdjust()
    }
    
    //Mark:出队
    func deQueue() -> Int
    {
        //获取堆顶元素
        let head:Int = array[0]
        size -= 1
        //最后一个元素移动到堆顶
        array[0] = array[size]
        downAdjust()
        return head
    }
    
    //Mark:上浮操作
    func upAdjust()
    {
        var childIndex:Int = size - 1
        var parentIndex:Int = (childIndex - 1)/2
        // temp保存插入的叶子节点值，用于最后的赋值
        let temp:Int = array[childIndex]
        while(childIndex > 0 && temp > array[parentIndex])
        {
            //无需真正交换，单向赋值即可
            array[childIndex] = array[parentIndex]
            childIndex = parentIndex
            parentIndex = parentIndex / 2
        }
        array[childIndex] = temp
    }
    
    //Mark:下沉操作
    func downAdjust()
    {
        // temp保存父节点值，用于最后的赋值
        var parentIndex:Int = 0
        let temp:Int = array[parentIndex]
        var childIndex:Int = 1
        while (childIndex < size)
        {
            // 如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子
            if childIndex + 1 < size && array[childIndex + 1] > array[childIndex]
            {
                childIndex += 1
            }
            // 如果父节点大于任何一个孩子的值，直接跳出
            if temp >= array[childIndex] {break}
            //无需真正交换，单向赋值即可
            array[parentIndex] = array[childIndex]
            parentIndex = childIndex
            childIndex = 2 * childIndex + 1
        }
         array[parentIndex] = temp
    }
}

测试：

let queue:PriorityQueue = PriorityQueue()
queue.enQueue(0)
queue.enQueue(9)
queue.enQueue(1)
queue.enQueue(8)
queue.enQueue(3)
print(queue.deQueue())
print(queue.deQueue())
print(queue.deQueue())
print(queue.deQueue())
print(queue.deQueue())
//Print 9
//Print 8
//Print 3
//Print 1
//Print 9

上面实现的是最大优先队列，我们想把优先队列是最大优先队列或最小的控制权限牢牢掌控在自己手中。甚至数组元素并非是Int类型。

一、自定义优先队列1:【PriorityQueue】。特别注意T可以为任何的数据结构。

public struct PriorityQueue<T> {
  fileprivate var heap: Heap<T>
  public init(sort: @escaping (T, T) -> Bool) {
    heap = Heap(sort: sort)
  }

  public var isEmpty: Bool {
    return heap.isEmpty
  }

  public var count: Int {
    return heap.count
  }

  public func peek() -> T? {
    return heap.peek()
  }

  public mutating func push(_ element: T) {
    heap.insert(element)
  }

  public mutating func pop() -> T? {
    return heap.remove()
  }

  public mutating func changePriority(index i: Int, value: T) {
    return heap.replace(index: i, value: value)
  }
}

extension PriorityQueue where T: Equatable {
  public func index(of element: T) -> Int? {
    return heap.index(of: element)
  }
}

public struct Heap<T> {
  var nodes = [T]()

  private var orderCriteria: (T, T) -> Bool

  public init(sort: @escaping (T, T) -> Bool) {
    self.orderCriteria = sort
  }
  
  public init(array: [T], sort: @escaping (T, T) -> Bool) {
    self.orderCriteria = sort
    configureHeap(from: array)
  }

  private mutating func configureHeap(from array: [T]) {
    nodes = array
    for i in stride(from: (nodes.count/2-1), through: 0, by: -1) {
      shiftDown(i)
    }
  }
  
  public var isEmpty: Bool {
    return nodes.isEmpty
  }
  
  public var count: Int {
    return nodes.count
  }

  @inline(__always) internal func parentIndex(ofIndex i: Int) -> Int {
    return (i - 1) / 2
  }

  @inline(__always) internal func leftChildIndex(ofIndex i: Int) -> Int {
    return 2*i + 1
  }

  @inline(__always) internal func rightChildIndex(ofIndex i: Int) -> Int {
    return 2*i + 2
  }
  
  public func peek() -> T? {
    return nodes.first
  }
  
  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()
  }

  internal mutating func shiftUp(_ index: Int) {
    var childIndex = index
    let child = nodes[childIndex]
    var parentIndex = self.parentIndex(ofIndex: childIndex)
    
    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 = leftChildIndex + 1

    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)
  }
  
}

extension Heap where T: Equatable {
    
    public func index(of node: T) -> Int? {
        return nodes.firstIndex(where: { $0 == node })
    }
    
    @discardableResult public mutating func remove(node: T) -> T? {
        if let index = index(of: node) {
            return remove(at: index)
        }
        return nil
    }
}

示例代码：

var pq = PriorityQueue<Int> { $0 > $1 }
pq.push(1)
pq.push(2)
pq.push(3)
dump(pq)
/*
▿ prog.PriorityQueue<Swift.Int>
  ▿ heap: prog.Heap<Swift.Int>
    ▿ nodes: 3 elements
      - 3
      - 1
      - 2
    - orderCriteria: (Function)
*/
print(pq.pop())
//Print Optional(3)

 二、自定义优先队列2:【PriorityQueue】

public struct PriorityQueue<T: Comparable> {    
    fileprivate var heap = [T]()
    private let ordered: (T, T) -> Bool
    
    //创建具有给定顺序的新PriorityQueue。
    //order：true:降序 | false：升序
    //StartingValues:用于初始化PriorityQueue的元素数组。
    public init(_ ascending: Bool = false,_ startingValues: [T] = []) {
        self.init(order: ascending ? { $0 > $1 } : { $0 < $1 }, startingValues: startingValues)
    }
    
    public init(order: @escaping (T, T) -> Bool, startingValues: [T] = []) {
        ordered = order        
        //堆构造
        heap = startingValues
        var i = heap.count/2 - 1
        while i >= 0 {
            sink(i)
            i -= 1
        }
    }
    
    //优先级队列存储了多少个元素
    public var count: Int { return heap.count }
    
    //如果且仅当优先级队列为空时为true
    public var isEmpty: Bool { return heap.isEmpty }
    
    // 在优先级队列中添加新元素,复杂度：O(lg n)
    // element: 要插入优先级队列的元素.
    public mutating func push(_ element: T) {
        heap.append(element)
        swim(heap.count - 1)
    }
    
    //移除并返回具有最高优先级的元素（如果升序，则为最低优先级）。复杂度： O(lg n)
    //returns:优先级队列中优先级最高的元素，如果优先级队列为空，则为零。
    public mutating func pop() -> T? {        
        if heap.isEmpty { return nil }
        //增加了Swift 2兼容性
        if heap.count == 1 { return heap.removeFirst() } 
        //以便不使用同一位置的两个实例调用swap()
        heap.swapAt(0, heap.count - 1)
        let temp = heap.removeLast()
        sink(0)        
        return temp
    }
    
    private mutating func sink(_ index: Int) {
        var index = index
        while 2 * index + 1 < heap.count {            
            var j = 2 * index + 1            
            if j < (heap.count - 1) && ordered(heap[j], heap[j + 1]) { j += 1 }
            if !ordered(heap[index], heap[j]) { break }            
            heap.swapAt(index, j)
            index = j
        }
    }
    
    private mutating func swim(_ index: Int) {
        var index = index
        while index > 0 && ordered(heap[(index - 1) / 2], heap[index]) {
            heap.swapAt((index - 1) / 2, index)
            index = (index - 1) / 2
        }
    }
}

示例代码：

var pq: PriorityQueue<Int> = PriorityQueue<Int>(false,[Int]())
pq.push(1)
pq.push(2)
pq.push(3)
dump(pq)
/*
▿ prog.PriorityQueue<Swift.Int>
  ▿ heap: 3 elements
    - 3
    - 1
    - 2
  - ordered: (Function)
*/
print(pq.pop())
//Print Optional(3)

---

 三、自定义优先队列3:【Heap】

public struct Heap {    
    var elements: [Int] = []
    let sort: (Int, Int) -> Bool
    var isEmpty: Bool {
        return self.elements.isEmpty
    }
    
    var count: Int {
        return self.elements.count
    }
    
    func peek() -> Int? {
        return elements.first
    }
    
    init(sort: @escaping (Int, Int) -> Bool, elements: [Int] = []) {
        self.sort = sort
        self.elements = elements
        
        if !elements.isEmpty {
            for i in stride(from: elements.count/2 - 1, through: 0, by: -1) {
                siftDown(from: i)
            }
        }
    }
    
    mutating func siftDown(from index: Int) {
        var parent = index
        while true {
            let left = leftIndex(of: parent)
            let right = rightIndex(of: parent)
            var candidate = parent
            if left < count && sort(elements[left], elements[candidate]) {
                candidate = left
            }
            if right < count && sort(elements[right], elements[candidate]) {
                candidate = right
            }
            if candidate == parent {
                return
            }
            elements.swapAt(parent, candidate)
            parent = candidate
        }
    }
    
    mutating func siftUp(from index: Int) {
        var child = index
        var parent = parentIndex(of: child)
        while child > 0 && sort(elements[child], elements[parent]) {
            elements.swapAt(child, parent)
            child = parent
            parent = parentIndex(of: child)
        }
    }
    
    mutating func push(_ element: Int) {
        elements.append(element)
        siftUp(from: count-1)
    }
    
    mutating func pop() -> Int? {
        guard !isEmpty else { return nil }
        elements.swapAt(0, count-1)
        defer {
            siftDown(from: 0)
        }
        return elements.popLast()
    }
    
    func leftIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightIndex(of index: Int) -> Int {
        return (2 * index) + 2
    }
    
    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }
}

示例代码：

var pq:Heap = Heap(sort: >)
pq.push(1)
pq.push(2)
pq.push(3)
dump(pq)
/*
▿ prog.Heap
  ▿ elements: 3 elements
    - 3
    - 1
    - 2
  - sort: (Function)
*/
print(pq.pop())
//Print Optional(3)

---

  四、自定义优先队列4:【Heap】

class Heap {
    var arr = [0]
    var count: Int {
        return arr.count-1
    }
    var top: Int {
        return arr[1]
    }
    func push(_ num: Int) -> Void {
        arr.append(num)
        var i = arr.count-1
        while i > 1 {
            if arr[i] > arr[i/2] {
                (arr[i], arr[i/2]) = (arr[i/2], arr[i])
            } else {
                break
            }
            i /= 2
        }
    }
    
    func pop() -> Int {
        var ret = self.top
        var last = arr.removeLast()
        if self.count == 0 {
            return ret
        }
        arr[1] = last
        var i = 1
        while i < arr.count {
            let left = i*2
            let right = i*2+1
            var next = i
            if left < arr.count && arr[left] > arr[next] {
                next = left
            }
            if right < arr.count && arr[right] > arr[next] {
                next = right
            }
            if i != next {
                (arr[i], arr[next]) = (arr[next], arr[i])
                i = next
            } else {
                break
            }               
        }
        return ret
    }
}

示例代码：

var pq:Heap = Heap()
pq.push(1)
pq.push(2)
pq.push(3)
dump(pq)
/*
▿ prog.Heap #0
  ▿ arr: 4 elements
    - 0
    - 3
    - 1
    - 2
*/
print(pq.pop())
//Print 3

---

五、自定义优先队列5:【Heap】

struct Heap<Element>
{
    var elements : [Element]
    let priorityFunction : (Element, Element) -> Bool

    init(elements: [Element] = [], priorityFunction: @escaping (Element, Element) -> Bool) {
        self.elements = elements
        self.priorityFunction = priorityFunction
        buildHeap()
    }

    mutating func buildHeap() {
        for index in (0 ..< count / 2).reversed() {
            siftDown(elementAtIndex: index)
        }
    }
    
    var isEmpty : Bool { return elements.isEmpty }
    var count : Int { return elements.count }

    func peek() -> Element? {
        return elements.first
    }

    mutating func push(_ element: Element) {
        elements.append(element)
        siftUp(elementAtIndex: count - 1)
    }

    mutating func siftUp(elementAtIndex index: Int) {
        let parent = parentIndex(of: index)
        guard !isRoot(index),
            isHigherPriority(at: index, than: parent)
            else { return }
        swapElement(at: index, with: parent)
        siftUp(elementAtIndex: parent)
    }

    mutating func pop() -> Element? {
        guard !isEmpty
            else { return nil }
        swapElement(at: 0, with: count - 1)
        let element = elements.removeLast()
        if !isEmpty {
            siftDown(elementAtIndex: 0)
        }
        return element
    }
    
    mutating func siftDown(elementAtIndex index: Int) {
        let childIndex = highestPriorityIndex(for: index)
        if index == childIndex {
            return
        }
        swapElement(at: index, with: childIndex)
        siftDown(elementAtIndex: childIndex)
    }

    // Helper functions    
    func isRoot(_ index: Int) -> Bool {
        return index == 0
    }
    
    func leftChildIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightChildIndex(of index: Int) -> Int {
        return (2 * index) + 2
    }
    
    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }
    
    func isHigherPriority(at firstIndex: Int, than secondIndex: Int) -> Bool {
        return priorityFunction(elements[firstIndex], elements[secondIndex])
    }
    
    func highestPriorityIndex(of parentIndex: Int, and childIndex: Int) -> Int {
        guard childIndex < count && isHigherPriority(at: childIndex, than: parentIndex)
            else { return parentIndex }
        return childIndex
    }
    
    func highestPriorityIndex(for parent: Int) -> Int {
        return highestPriorityIndex(of: highestPriorityIndex(of: parent, and: leftChildIndex(of: parent)), and: rightChildIndex(of: parent))
    }
    
    mutating func swapElement(at firstIndex: Int, with secondIndex: Int) {
        guard firstIndex != secondIndex
            else { return }
        elements.swapAt(firstIndex, secondIndex)
    }
}

extension Heap where Element : Equatable {
    mutating func remove(_ element: Element) {
        guard let index = elements.index(of: element)
            else { return }
        swapElement(at: index, with: count - 1)
        elements.remove(at: count - 1)
        siftDown(elementAtIndex: index)
    }

    mutating func boost(_ element: Element) {
        guard let index = elements.index(of: element)
            else { return }
        siftUp(elementAtIndex: index)
    }
}

示例代码：

var pq = Heap<Int>(elements: [], priorityFunction: >)
pq.push(1)
pq.push(2)
pq.push(3)
dump(pq)
/*
▿ prog.Heap<Swift.Int>
  ▿ elements: 3 elements
    - 3
    - 1
    - 2
  - priorityFunction: (Function)
*/
print(pq.pop())
//Print Optional(3)