堆排序

 

1. 堆

    （二叉）堆数据结构是一种数组对象，可以视为一颗完全二叉树。表示堆的数组A是一个具有两个属性的对象：length[A] 是数组中的元素个数， heap-size[A] 是存放在A中的堆的元素个数。树的根为A[1]， 给定某个节点的下标i，

    PARENT(i)         return 「i/2」

    LEFT(i)               return 2i

    RIGHT(i)            return 2i + 1

    最大堆的特性是，指除了根以外的每个节点i, 有  A[PARENT(i)] ≥ A[i]，最小堆与之相反。

 

2. MAX-HEAPIFY(A,i) 保持堆的性质

    输入：数组A和下标i                         目的：使以i为根的子树成为最大堆

    MAX-HEAPIFY(A,i)

    1    l <-- LEFT(i)

    2    r <-- RIGHT(i)

    3    if l ≤ heap-size[A] and A[l] > A[i]

    4           then largest <-- l

    5           else largest <-- i

    6    if r ≤ heap-size[A] and A[r] > A[largest]

    7           then largest <--r

    8    if largest ≠ i

    9          then exchange A[i] <--> A[largest]

    10               MAX-HEAPIFY (A, largest)

 

3. 建堆

    自底向上地用MAX-HEAPIFY来将一个数组[1 .. n] (此处n = length[A]) 变成一个最大堆。 证明可知 子数组A[( PARENT(n) + 1) .. n] 中的元素都是树中的叶子， 因此每个都可看做是只含一个元素的堆，故：

    BUILD-MAX-HEAP(A)

    1   heap-size(A) <-- length[A]

    2   for i <-- 「length[A] /2」+ 1 downto 1

    3           do MAX-HEAPIFY(A, i)

 

4. 堆排序算法

    HEAPSORT(A)

    1   BUILD-MAX-HEAP(A)

    2   for i <-- length[A] downto 2

    3           do exchange A[1] <--> A[i]

    4                  heap-size[A] <-- heap-size[A] -1

    5                  MAX-HEAPIFY(A, 1)

 

5. 优先级队列

    最大优先级队列支持的操作及实现：

    INSERT(S, x)：把元素x插入集合S ；

    MAXIMUM(S)：返回S中具有最大关键字的元素 ；

    EXTRACT-MAX(S)：去掉并返回S中的具有最大关键字的元素 ；

    INCREASE-KEY(S, x, k)：将元素x的关键字的值增加到k，这里k值不能小于原关键字的值。

 

    HAEP-MAXIMUM(A)

    1   return  A[1]

 

    HEAP-EXTRACT-MAX(A)

    1   if heap-size[A] < 1

    2      then error "heap underflow"

    3   max <-- A[1]

    4   A[1] <-- A[heap-size[A]]

    5   heap-size[A] <-- heap-size[A] -1

    6   MAX-HEAPIFY(A, 1)

    7   return max

 

    HEAP-INCREASE-KEY(A, i, key)

    1   if key < A[i]

    2      then error "new key is smaller than current key"

    3   A[i] <-- key

    4   while i>1 and A[parent(i)] < A[i]

    5      do exchange A[i] <--> A[parent(i)]

    6            i <-- parent(i)

 

    MAX-HEAP-INSERT(A,key)

    1   heap-size[A] <-- heap-size[A] + 1

    2   A[heap-size[A]] <-- -∞

    3   HEAP-INCREASE-KEY(A, heap-size[A], key)