《数据结构与算法分析：C语言描述》复习——第六章“排序”——堆排序

2014.06.17 03:29

简介：

　　堆排序，是从这本教材上看，最好的排序算法。它是稳定排序，时间复杂度稳定保持在O(n * log(n))，空间复杂度为O(1)。原理非常简单，实现也比较简单。但是，应用却不如快速排序和归并排序那么广。原因咱们下面说说。

描述：

　　如果你要把数组排成升序，你可以依次把最小的元素放前面，或把最大的元素往后放。我们在第五章学习了堆，知道可以用数组来表示一个堆。那么我们就通过建堆算法，把这个数组变成一个大顶堆，堆顶元素最大。每次从这个堆拿出堆顶放在数组的后面，放了n - 1次以后，整个数组就排好序了。

　　那堆排序有什么不如快速排序的呢？应该是输在常系数上了，从代码里可以看到堆排序在随机访问元素的时候，下标的变化很大。如果你还考虑了内存里数据寻址的耗时，那么快速排序、归并排序要访问的内存总是离得更近（人家用的是++和--），这样就不会像堆排序那样到处寻址了。不过，这个理由也没有很大的说服力。因为你自己手写一个快速排序和堆排序进行比较，很有可能堆排序会胜出。而目前最优秀的排序算法sort君，其内涵是非常丰富的，绝不是简单的快速排序。纠结于这些算法到底谁最好，不如取长补短。在找工作时，堆排序确实有个实实在在的好处，当你写不出快排的时候，堆排序就容易多了。因为——不论快速排序还是快速选择，都是既不好分析又容易写错的算法。如果sort不让用，还是堆排序吧；万一堆排序也忘了，就归并了吧；如果归并也忘了，你就回家等通知吧。

实现：

// My implementation for selection sort.
#include <iostream>
#include <vector>
using namespace std;

static inline int leftChild(int n)
{
    return n * 2 + 1;
}

static inline int rightChild(int n)
{
    return n * 2 + 2;
}

static inline void swap(int &x, int &y)
{
    int tmp;
    
    tmp = x;
    x = y;
    y = tmp;
}

static inline int max(const int &x, const int &y)
{
    return x > y ? x : y;
}

static void percolateDown(vector<int> &v, int i, int n)
{
    if (n <= 1 || i < 0 || i >= n) {
        return;
    }
    int max_val;

    while (leftChild(i) < n) {
        if (leftChild(i) == n - 1) {
            max_val = v[leftChild(i)];
        } else {
            max_val = max(v[leftChild(i)], v[rightChild(i)]);
        }
        if (v[i] < max_val) {
            if (max_val == v[leftChild(i)]) {
                swap(v[i], v[leftChild(i)]);
                i = leftChild(i);
            } else {
                swap(v[i], v[rightChild(i)]);
                i = rightChild(i);
            }
        } else {
            break;
        }
    }
}

void heapSort(vector<int> &v)
{
    int n;
    int i;
    
    n = (int)v.size();
    for (i = (n - 1) / 2; i >= 0; --i) {
        percolateDown(v, i, n);
    }
    
    int val;
    for (i = 0; i < n - 1; ++i) {
        val = v[0];
        v[0] = v[n - 1 - i];
        percolateDown(v, 0, n - 1 - i);
        v[n - 1 - i] = val;
    }
}

int main()
{
    vector<int> v;
    int n, i;
    
    while (cin >> n && n > 0) {
        v.resize(n);
        for (i = 0; i < n; ++i) {
            cin >> v[i];
        }
        heapSort(v);
        for (i = 0; i < n; ++i) {
            cout << v[i] << ' ';
        }
        cout << endl;
    }
    
    return 0;
}