算法导论---第6章---堆排序

算法导论---第6章---堆排序

1、堆排序简介

　　堆排序（heapsort）。与归并排序一样，但不同于插入排序的是，堆排序的时间复杂度是O(nlgn)。而与插入排序相同，但不同于归并排序的是，堆排序同样具有空间原址性：任何时候都只需要常数个额外的元素存储临时数据。因此，堆排序是集合了插入排序和归并排序这两种排序算法优点的一种排序算法。

2、基本过程

　　MAX-HEAPIFY过程：其时间复杂度为O(lgn)，它是维护最大堆性质的关键。

　　BUILD-MAX-HEAP过程：具有线性时间复杂度，功能是从无序的输入数据数组中构造一个最大堆。

　　HEAPSORT过程：其时间复杂度为O(nlgn)，功能是对一个数组进行原址排序。

3、算法描述

　　首先，堆排序算法利用BUILD-MAX-HEAP将输入数组A[1...n]建成最大堆，其中n=A.length。因为数组中的最大元素总在根节点A[1]中，通过把它与A[n]进行互换，我们可以让该元素放到正确的位置。这时候，如果我们从堆中去掉节点n（这一操作可以通过减少A.heap-size的值来实现），剩余的节点中，原来根的孩子节点仍然是最大堆，而新的根节点可能会违背最大堆的性质。为了维护最大堆的性质，我们要做的是调用MAX-HEAPIFY(A, 1)，从而在A[1...n-1]上构造一个新的最大堆。堆排序算法会不断重复这一过程，知道堆得大小从n-1降到2.

　　算法伪代码描述如下：

　　PARENT(i)

　　1　　return ⌊i/2⌋

　　LEFT(i)

　　1　　return 2i

　　RIGHT(i)

　　1　　return 2i+1

　　MAX-HEAPIFY(A, i)

　　1　　l = LEFT(i)

　　2　　r = RIGHT(i)

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

　　4　　　　largest = l

　　5　　else largest = i

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

　　7　　　　largest = r

　　8　　if largest ≠ i

　　9　　　　exchange A[i] with A[largest]

　　10　　　  MAX-HEAPIFY(A, largest)

　　BUILD-MAX-HEAP(A)

　　1　　A.heap-size = A.length

　　2　　for i = ⌊A.length/2⌋ downto 1

　　3　　　　MAX-HEAPIFY(A, i)

　　HEAPSORT(A)

　　1　　BUILD-MAX-HEAP(A)

　　2　　for i = A.length downto 2

　　3　　　　exchange A[1] with A[i]

　　4　　　　A.heap-size = A.heap-size - 1

　　5　　　　MAX-HEAPIFY(A, 1)

4、算法代码（C++实现）

　　ps：因为伪码中数组A的起始小标为1，而实际编写C++代码中，数组的起始下标为0，所以这里要注意计算父节点、子节点的下标公式与伪码中不同，同时需要注意循环体的结束条件也与伪码中略有差异。

#include <iostream>
#include <math.h>
#include <stdio.h>

using namespace std;

inline int PARENT(int i) {return (i+1)/2 - 1;};
inline int LEFT(int i) {return 2*i+1;};
inline int RIGHT(int i) {return (2*i+2);};

void Max_Heapify(int *a, int length, int i);
void Max_BuildHeap(int *a, int length);
void Max_HeapSort(int *a, int length);

int main()
{
    int a[] = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};
    int length = 10;

    Max_HeapSort(a, length);

    cout << "Result of Max_HeapSort(): " << endl;
    for (int i = 0; i < length; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;

    return 0;
}


void exchange(int &a, int &b)
{
    // 交换变量 a 和 b 的值
    if (a == b)
    {
        return;
    }
    int tmp = a;
    a = b;
    b = tmp;
}

void Max_Heapify(int a[],int length, int i)
{
    // 对数组 a 的第 i 个元素进行堆化操作
    if (a == NULL)
    {
        cerr << "Max_Heapify(): Array is NULL!" << endl;
        return;
    }
    int heap_size = length;

    int l = LEFT(i);
    int r = RIGHT(i);
    int largest;

    if (l < heap_size && a[l] > a[i])
    {
        largest = l;
    }
    else
    {
        largest = i;
    }
    if (r < heap_size && a[r] > a[largest])
    {
        largest = r;
    }
    if(largest != i)
    {
        exchange(a[i], a[largest]);
        Max_Heapify(a, length, largest);
    }
}

void Max_BuildHeap(int a[], int length)
{
    // 建立最大堆
    if (a == NULL)
    {
        cerr << "Max_BuildHeap(): Array is NULL!" << endl;
        return;
    }
    for (int i = floor((length-1)/2); i >= 0; i--)
    {
        Max_Heapify(a, length, i);
    }
}

void Max_HeapSort(int a[], int length)
{
    // 最大堆排序
    if (a == NULL)
    {
        cerr << "Max_HeapSort(): Array is NULL!" << endl;
        return;
    }
    int heap_size = length;
    Max_BuildHeap(a, length);

    cout << "Result of Max_BuildHeap(): " << endl;
    for (int i = 0; i < length; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;

    for (int i = length-1; i >= 1; i--)
    {
        exchange(a[0], a[i]);
        heap_size -= 1;
        Max_Heapify(a, heap_size, 0);
    }
}

　　运行结果如下：