优先队列解构：Swift中的图解实现

IOS

2023-10-04 09:08:30

导言

在计算机科学的浩瀚世界中，优先队列脱颖而出，作为一种高效的数据结构，能够管理按优先级排列的元素。它允许我们在需要时轻松地检索最高优先级的元素，同时维护内部元素的优先级顺序。

深入浅出：优先队列

想象一下，你面前有一条队列，人们按照他们到达的顺序排队。但是，并不是所有的人都生而平等，一些人有着更高的优先级，需要优先处理。优先队列就是为了应对这样的场景而设计的。

在优先队列中，每个元素都分配了一个优先级，表示其在队列中的重要性。当需要检索一个元素时，优先队列会返回具有最高优先级的元素。即使在移除了最高优先级的元素后，队列也会自动重新排序内部元素，确保新出现的最高优先级的元素能够被快速访问。

Swift中的图解实现

为了生动形象地展示优先队列的工作原理，我们将在Swift中进行图解实现。首先，我们创建一个名为PriorityQueue的类：

class PriorityQueue<T: Comparable> {
    private var heap: [T] = []

    func enqueue(_ element: T) {
        heap.append(element)
        siftUp(heap.count - 1)
    }

    func dequeue() -> T? {
        guard !heap.isEmpty else { return nil }

        let root = heap[0]
        heap[0] = heap[heap.count - 1]
        heap.removeLast()
        siftDown(0)
        return root
    }

    private func siftUp(_ index: Int) {
        var childIndex = index
        var parentIndex = childIndex / 2

        while childIndex > 0 && heap[childIndex] > heap[parentIndex] {
            heap.swapAt(childIndex, parentIndex)
            childIndex = parentIndex
            parentIndex = childIndex / 2
        }
    }

    private func siftDown(_ index: Int) {
        var parentIndex = index
        var leftChildIndex = parentIndex * 2 + 1
        var rightChildIndex = parentIndex * 2 + 2

        while leftChildIndex < heap.count {
            let maxChildIndex = rightChildIndex < heap.count && heap[rightChildIndex] > heap[leftChildIndex] ? rightChildIndex : leftChildIndex

            if heap[parentIndex] < heap[maxChildIndex] {
                heap.swapAt(parentIndex, maxChildIndex)
                parentIndex = maxChildIndex
                leftChildIndex = parentIndex * 2 + 1
                rightChildIndex = parentIndex * 2 + 2
            } else {
                break
            }
        }
    }
}

在这个实现中，优先队列使用一个堆数据结构，将元素组织成一个树状结构，其中每个节点的优先级都高于或等于其子节点的优先级。

图示示例

假设我们有一个数据流：1，2，3，4，5，6，7，8。我们将使用我们的PriorityQueue类来管理这个数据流并按升序查找最高优先级的元素：

插入数据流： 我们将依次插入数据流中的每个元素到优先队列中。
查找最高优先级的元素： 通过调用dequeue方法，我们将始终得到当前队列中优先级最高的元素。
图解表示： 以下图表展示了优先队列在每个步骤中的状态：

**数据流：1，2，3，4，5，6，7，8** 

**步骤 1：插入 1** 
        1
        
**步骤 2：插入 2** 
         1
        /   \
       2     NULL
       
**步骤 3：插入 3** 
         1
        /   \
       2     3
       
**步骤 4：插入 4** 
         1
        /   \
       2     3
      / \
     4   NULL
       
**步骤 5：插入 5** 
          1
        /    \
       2      3
      / \    / \
     4   NULL 5  NULL

**步骤 6：插入 6** 
           1
         /    \
        2      3
       / \    / \
      4   NULL 5   6
       
**步骤 7：插入 7** 
           1
         /    \
        2      3
       / \    / \
      4   NULL 5   6
     / \
    7   NULL

**步骤 8：插入 8** 
           1
         /    \
        2      3
       / \    / \
      4   NULL 5   6
     / \     / \
    7   8    NULL NULL

**步骤 9：查找最高优先级的元素** 
       1