算法-排序-选择排序（直接选择和堆排序）

这里介绍两种选择排序算法：直接选择排序和堆排序

选择排序基本思想：每一趟从待排序的序列中选出关键字最小（最大）的元素，顺序放在已排好序的子序列的最后，直到全部元素排序完毕。

1、直接选择排序

基本原理：每一次从待排序序列中选取最小的元素顺序放在以排好的序列后面，例如序列R，先从R中选择最小的元素，将之与R[0]交换，使这个最小值在序列最前端，然后再在剩余的n-1个元素中选取最小的元素与R[1]交换，使之在序列的第二个位置，依此循环，直到最后排序完毕，n个元素的序列共需要进行n-1次比较选择就可以得到排序后的序列。直接选择排序属于就地排序，但是是不稳定的例如（2,2,1）。
动画：http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/zhijiexuanze.htm

2、堆排序

堆在百度百科中定义：n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）：
(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n/2），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶子结点，K(2i）则是左子节点，k(2i+1）是右子节点

若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。
【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如小根堆示例和大根堆示例所示。

堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。

大根堆排序基本原理和过程：利用堆的结构特征，将堆顶最大元素和堆尾元素交换，使之处于堆尾，然后对堆进行调整，使剩余的元素中最大的又在堆顶，从而与堆尾倒数第尔个数交换，循环，就能将堆重的元素从大到小依次从堆尾排到堆顶；前提是要初始化堆，使数据按堆的结构排列；
动画：http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/duipaixu.htm

下面简单说明一下大根堆排序实现代码：这里新建了3个函数：
void heapinit(vector &vec);
void heapsock(vector &vec);
void heapadjust(vector &vec,int n,int m);
分别用来进行堆初始化，堆排序，堆调整；
初始数据要通过堆初始化，使数据结构符合大根堆的结构模式。然后对堆进行排序，每选择一次堆元素（堆顶元素排序）后，需要重新对剩余数据进行调整，使之依然符合堆结构。

下面为两种排序方法的代码实现：

#include <iostream>#include <vector>using namespace std;const int N = 20;    //定义常量    也可以这样 #define N 20 void disp(vector<int> vec);          //输出函数,void selectsort(vector<int> &vec);   //直接选择算法void selectsort2(vector<int> &vec);  //直接选择算法2(改进) void heapinit(vector<int> &vec);     //堆初始void heapsock(vector<int> &vec);     //排序void heapadjust(vector<int> &vec,int n,int m);   //堆调整int main(){    vector<int> vec1(N),vec2;    int a[N] = {2 ,19 ,3 ,25 ,4 ,0,8,22,10,2,9,45,12,16,21,41,6,18,34,10};    for(int i = 0; i < N; i++)        vec1[i] = a[i];    vec2 = vec1;    vec2[0] = 0;      //这里为了方便，堆排序从vec2[1]开始    disp(vec1);    disp(vec2);    selectsort2(vec1);      //直接选择排序    heapsock(vec2);         //堆排序    disp(vec1);    disp(vec2);    return 0;}void disp(vector<int> vec)   //输出函数{    cout << "排列顺序为：";    for(int i = 0; i < N; i++)        cout << vec[i] << "    ";    cout << endl;}void selectsort(vector<int> &vec){    int temp;    for(int i = 0; i < N-1; i++)     //每循环一次，获取一个最小值    {        for(int j = i+1; j < N; j++) //获取剩余序列的最小值放在顺序序列后        {            if(vec[i] > vec[j])            {                temp = vec[i];                vec[i] = vec[j];                vec[j] = temp;            }        }    }}//另一种实现方法，不用每次都对值进行交换，只需记录位置信息即可void selectsort2(vector<int> &vec){    int temp, pos;    for(int i = 0; i < N-1; i++)    {        pos = i;        for(int j = i+1; j < N; j++ )        {            if(vec[pos] > vec[j])                pos = j;     //获取最小值位置        }        if(pos != i)        {            temp = vec[i];            vec[i] = vec[pos];            vec[pos] = temp;        }    }}void heapinit(vector<int> &vec)//注意这里树的顶端节点为1，不是0,为了方便，这里对vec1的1-19个数排序，忽略vec[0]{    vec[0] = 0;    //假设不对vec[0]排序，只处理1-n的数    int temp = 0;    for(int i = (N-1)/2; i >= 1; i--)    //从倒数第二层开始涮选出最大的值为堆顶    {        if(2*i + 1 <= N-1)          //左右都有子节点的情况        {            if(vec[i] < vec[2*i] || vec[i] < vec[2*i + 1])//小于左右两个子节点中的任何一个            {                temp = vec[i];                vec[i] = max(vec[2*i],vec[2*i+1]);     //取最大                if(vec[2*i] > vec[2*i+1])                    vec[2*i] = temp;                else                    vec[2*i+1] = temp;            }        }        else if(2*i <= N-1 && 2*i + 1 > N-1)     //只有左子节点的情况        {            if(vec[i] < vec[2*i] )//            {                temp = vec[i];                vec[i] = vec[2*i];     //                vec[2*i] = temp;            }        }    }    heapadjust(vec,2,N-1);  //从堆的第二个节点开始进行调整    /*    for(int j = 2; j<=(N-1)/2; j++)         //从第二个节点开始，向下调整堆    {        if(2*j + 1 <= N-1)        {            if(vec[j] < vec[2*j] || vec[j] < vec[2*j + 1])//小于左右两个子节点中的任何一个            {                temp = vec[j];                vec[j] = max(vec[2*j],vec[2*j+1]);     //取最大                if(vec[2*j] > vec[2*j+1])                    vec[2*j] = temp;                else                    vec[2*j+1] = temp;            }        }        else if(2*j <= N-1 && 2*j + 1 > N-1)     //注意边界,只有左子节点的情况        {            if(vec[j] < vec[2*j] )//            {                temp = vec[j];                vec[j] = vec[2*j];     //                vec[2*j] = temp;            }        }    }    */}void heapsock(vector<int> &vec){    int temp;    heapinit(vec);    for(int i = N-1; i>1; i--)    {        temp = vec[i];    //把堆顶最大的数放在序列末尾（和末尾的数交换）        vec[i] = vec[1];        vec[1] = temp;        heapadjust(vec,1,i-1);        //调整堆，使剩余数的最大值在堆顶    }}void heapadjust(vector<int> &vec, int n, int m){    int temp;    for(int j = n; j <= m/2; j++)    //与堆初始化中第二步相似    {        if(2*j + 1 <= m)        {            if(vec[j] < vec[2*j] || vec[j] < vec[2*j + 1])//小于左右两个子节点中的任何一个            {                temp = vec[j];                vec[j] = max(vec[2*j],vec[2*j+1]);     //取最大                if(vec[2*j] > vec[2*j+1])                    vec[2*j] = temp;                else                    vec[2*j+1] = temp;            }        }        else if(2*j <= m && 2*j + 1 > m)     //注意边界,只有左子节点的情况        {            if(vec[j] < vec[2*j] )//            {                temp = vec[j];                vec[j] = vec[2*j];     //                vec[2*j] = temp;            }        }    }}