选择排序(包含堆排序)

思路

每一趟都从n-i+1（i=1,2,3….n-1）个记录中选择出最小的关键字，作为有序序列的第i个元素。

常用的选择排序

• 简单选择排序
• 堆排序

简单选择排序

思路 （参考：选择排序）

数组A，长度为：n，临时变量：i,初始化为1
- 从A[i]~A[n]这n-i+1个元素中，找出最小的关键字，并且记录其下标
- 如果该关键字不是A[i]~A[n]这个序列的第一个元素，则将该两个位置的元素替换
- 将i从1~n-1，递增循环执行上述两个步骤

代码实现

#include<iostream>using namespace std;typedef int Datatype;    //编译期多态的一种：转换void print(Datatype * data, int i, int length) {    int j = 0;    cout << "第" << i + 1 << "趟排序：";    for (j = 0; j < length; ++j) {        cout << data[j] << " ";    }    cout << endl;}void EasySelectSort(Datatype * data, const int length) {    int i = 0;    int j = 0;    Datatype min;    int temp = 0;    for (i = 0; i < length-1; ++i) {    //只需要确认前length-1个元素的顺序，则最后一个位置的元素的位置也就确定了        temp = i;                       //记录temp        for (j=i; j < length; ++j) {    //找出最小的那个关键字的位置。             if (data[j] < data[temp]) {                temp = j;            }        }        if (temp != i) {   //判断是否需要交换两个位置上的元素            min = data[temp];            data[temp] = data[i];            data[i] = min;        }        print(data, i, length);    }}void main() {    int data[] = { 7,4,-2,19,13,6 };    EasySelectSort(data, sizeof(data) / sizeof(int));    system("pause");}

结果：

时间复杂度分析

我们通过分析可以知道，我们程序无论是什么情况，都要比较：n*(n-1)/2次。所以程序的时间复杂度为：O(n^2)。

是否稳定

稳定的定义就是：两个相同的数，在排完序后前后的相对顺序没有改变。对于简单选择排序，它是不稳定的，我可以简单的举个例子：{7,7,2}，当我们进行简单选择排序后，第一个7会和2调换位置，从出现不稳定的情况

堆排序

简单的选择排序为了得出有序的序列，对于任意序列都要比较：n*(n-1)/2次。那么我们要优化这个算法的话，那么就要减少我们的比较的次数。所以从比较这里出发：我们为得出n个关键字中的最小的值，需要比较n-1次，而下一次要得出n-1个关键字中最小的值时，同样又要比较n-2次，如果我们可以利用之前的n-1次的比较结果，那么我们就可能在下一次寻找中，减少比较次数，从而就可以提高程序的效率了。堆就可以记录这些信息，所以我们就提出了另外一种优化的选择排序：堆排序

思路

用一个完全二叉树来表示堆，堆有两种：最大堆和最小堆。
- 最大堆：所有结点都比它们的左右孩子大。调整过程出现两个孩子结点，都大于父结点，选择大的那个替换。
- 最小堆：所有结点都比它们的左右孩子小。调整过程出现两个孩子结点，都小于父结点，选择小的那个替换。

堆排序的大体思路是（以最小堆为例）：
- 首先建立初始堆
- 输出根结点，用最后一个结点替换根结点，删除最后一个结点，并且对堆进行调整，使其还是满足最小堆的性质。
- 重复，第二个过程，直到堆为空为止

实现过程

我们从思路分析，可以知道我们需要解决两个问题：
- 建立初始堆
- 输出后，对堆的调整

程序实现

void HeapAdjust(Datatype * data, int length, int s) {    //最小堆    int j = 0;    Datatype temp = data[s];    j = 2 * s + 1;    for (; j <= length; j = 2 * j + 1) {        /*        最大堆需要修改：下面两个if语句，        */        //如果左子树小于右子树，则让右子树去和根结点比较        if (j < length && data[j] > data[j + 1]) {            ++j;        }        //此时已经满足最小堆了条件了，可以停止寻找了        if (temp <= data[j]) {            break;        }        //交换根结点和孩子结点的值        data[s] = data[j];        s = j;    }    //最后，确定了我们那个关键需要存放的地方    data[s] = temp;}void HeapSort(Datatype * data, int length) {    for (int i = (length / 2)-1; i >= 0; --i) {        HeapAdjust(data, length-1, i);    }    int n = length - 1;    //这里我们只需要比较前length-1个数，最后一个数的值也就确定了    while (n >= 1) {        Datatype temp;        temp = data[0];        data[0] = data[n];        data[n] = temp;        cout << temp << " ";        --n;        HeapAdjust(data, n, 0);    }    cout << data[n];    cout << endl;}

在主函数中，调用上述的HeapSort函数，就可以进行堆排序了。

时间复杂度分析

这里的时间主要是花费在调用heapAdjust函数中，HeapAdjust函数最多做：⌈log2n⌉次调整，总共需要调用：(n/2）+(n-1)次HeapAdjust函数，所以该时间复杂度为：O（nlog2n）

是否稳定

堆排序是不稳定的排序算法，比如有无序的序列：{3,27,36,27}，所以在输出3后，最后的那个27替换到了根节点，从这里就可以看出该算法是不稳定的。

总结

堆排序的时间复杂也是为：O（nlog2n），而且是最多就是：O（nlog2n）。对于时间复杂同样是：O（nlog2n）的排序算法：快速排序和归并排序来说，它只是在最坏情况下是占优势的。具体可以参考：
堆和快排、归并的比较