堆排序

最新推荐文章于 2024-06-09 16:03:45 发布

原创最新推荐文章于 2024-06-09 16:03:45 发布 · 316 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了堆排序算法的核心概念，包括最大堆与最小堆的区别、如何通过宏过程或内联过程实现节点计算，以及堆排序的具体步骤。此外还提供了构建最大堆的方法，并分析了堆排序的时间复杂度。

给定某个节点的下标，其父节点、左孩子与右孩子的下标可以简单的计算出来

PARENT(i)

return [i/2] (下取整)

LEFT(i)

return 2i

RIGHT

return 2i+1

一个好的堆排序的实现，这三个过程通常是用宏过程或内联过程实现的。

二叉堆有两种：最大堆和最小堆(小根堆)。

最大堆：所有节点的子节点比其自身小的堆。
最小堆：所有节点的子节点比其自身大的堆。

在堆排序算法中，我们使用的是最大堆。最小堆通常在构造优先队列时使用。

节点在堆中的高度定义为从本节点到叶子的最长简单下降路径上边的数目，定义堆得高度为树根的高度。

因为具有n个元素的堆是基于一棵完全二叉树，因此其高度为O(lgn)。

CLRS上的伪代码

MAX-HEAPIFY(A,i)
    l <- left(i)
    r <- right(i)
    if l<= heap-size[A] and A[l]>A[i]
        then largest  <- l
        else largest  <- i
   if  r<= heap-size[A] and A[r] >A[largest]
        then  largest <- r
   if largest != i
       then exchange A[i]  <=> A[largest]
            MAX-HEAPIFY(A,largest)

从伪代码可以看出，前七行在找A[i],A[LEFT(i)],A[RIGHT(i)]三个元素的最大值，调整三者的关系时间为O(1)，再加上对以i的某个子节点尾根的子树递归调用MAX-HEAPIFY所需时间。i节点的字数大小至多是2n/3（最坏情况发生在最底层恰好半满的时候，这块需要仔细想一下为什么），则

T(n) <= T(2n/3) +O(1)

根据主定理，得到递归式的解为T(n) = O(lgn)。即MAX-HEAPIFY作为一个高度为h的节点所需的运行时间为O(h)。

void MaxHeapify(int *a, int i, int size)
 {
 	int lt = 2*i, rt = 2*i+1;
 	int largest;
 	if(lt <= size && a[lt] > a[i])
 		largest = lt;
 	else
 		largest = i;
 	if(rt <= size && a[rt] > a[largest])
 		largest = rt;  //寻找三个值中的最大值
 	if(largest != i)     //如果有子节点大于根节点，交换，节点下降，继续递归运算
 	{
 		int temp = a[i];
 		a[i] = a[largest];
 		a[largest] = temp;
 		MaxHeapify(a, largest, size);
 	}
 }

建堆

伪代码

BUILD-MAX-HEAP(A)
    heap-size(A) <- length(A)
    for  i<- [length[A]/2] downto 1 //[ ] 表示下取整
         do MAX_HEAPIFY(A,i)

在第一轮循环迭代前， i=[n/2]。节点[n/2]+1, [n/2]+2,......,都是叶节点也是平凡最大堆的根。

通过计算可以得到，BUILD-MAX-HEAP的运行时间界为O(n)，也就是可以在线性时间内，将一个无序数组建成一个最大堆。注意界不是O(nlgn)，虽然这个界是对的，但从渐进意义上讲不够紧确。

void BuildMaxHeap(int *a, int size)
 {
 	for(int i=size/2; i>=1; --i)
 		MaxHeapify(a, i, size);
 }

堆排序算法

HEAPSORT(A)
   BUILD_MAX_HEAP(A)
   for i <- length[A]  downto 2
        do  exchange   A[1]  <-> A[i]
              heap-size  <-   heap-size[A]-1
              MAX-HEAPIFY(A,1)

所谓堆排序，就是首先由一个数组构建一个最大堆，然后将这些值按照从大到小的顺序依次输出，所以需要多次调用MAX-HEAPIFY函数。

void HeapSort(int *a, int size)
 {
 	BuildMaxHeap(a, size);
 	int len = size;
 	for(int i=size; i>=2; --i)
 	{
 		int temp = a[1];
 		a[1] = a[i];
 		a[i] = temp;
 		len--;
 		MaxHeapify(a, 1, len);
 	}
 }

堆排序的时间代价为O(nlgn)