内部排序之选择排序(直接选择排序，堆排序)

目录

1. 堆排序简介及其代码
2. 直接选择排序简介及其代码
3. 选择排序总结

---

堆排序简介及其代码

1、首先明确完全二叉树概念：

　　深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时，称为完全二叉树。

其次明确堆的概念：

　　堆是具有以下性质的完全二叉树，每个结点的值小于或等于其孩子结点的值（小根堆），每个结点的值大于或等于其孩子结点的值（大根堆）

堆的定义如图所示:

2、堆排序的关键在于建堆，下面简单介绍一下建堆的过程：

第1趟将索引0至n-1处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的最后一个节点交换，就使的这组数据中最大（最小）值排在了最后。

第2趟将索引0至n-2处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的倒数第二个节点交换，就使的这组数据中最大（最小）值排在了倒数第二位。

……

第k趟将索引0至n-k处的全部数据建大顶（或小顶）堆，就可以选出这组数据的最大值（或最小值）。将该堆的根节点与这组数据的倒数第k个节点交换，就使的这组数据中最大（最小）值排在了倒数第k位。

所以我们只是在重复做两件事：

1：建堆(建堆从最后一个非叶子节点开始即可)
2：拿堆的根节点和最后一个节点交换

下面通过一组数据说明：

9,79,46,30,58,49

1:先将其转换为完全二叉树，如图

2：完全二叉树的最后一个非叶子节点，也就是最后一个节点的父节点。最后一个节点的索引为数组长度len-1，那么最后一个非叶子节点的索引应该是为(len-1)/2.也就是从索引为2的节点开始，如果其子节点的值大于其本身的值。则把他和较大子节点进行交换，即将索引2处节点和索引5处元素交换。交换后的结果如图：

3：向前处理前一个节点，也就是处理索引为1的节点，此时79>30,79>58,因此无需交换。

4：向前处理前一个节点，也就是处理索引为0的节点，此时9<79,9<49,因此无需交换。应该拿索引为0的节点与索引为1的节点交换，因为79>49.如图

5：如果某个节点和它的某个子节点交换后，该子节点又有子节点，系统还需要再次对该子节点进行判断。如上图因为1处，3处，4处中，1处的值大于3,4出的值，所以还要交换。

---

代码块：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 20

typedef int KeyType;
typedef char InfoType[10];
typedef struct
{
    KeyType key;
    InfoType data;
}RecType;
void sift(RecType R[], int low, int high)
{
    int i = low, j = 2 * i;                        //R[j]是R[i]的左孩子
    RecType temp = R[i];
    while (j <= high)
    {
        if (j<high && R[j].key<R[j + 1].key)  //若右孩子较大,把j指向右孩子
            j++;                                //变为2i+1
        if (temp.key<R[j].key)
        {
            R[i] = R[j];                          //将R[j]调整到双亲结点位置上
            i = j;                                //修改i和j值,以便继续向下筛选
            j = 2 * i;
        }
        else break;                             //筛选结束
    }
    R[i] = temp;                                  //被筛选结点的值放入最终位置
}

void HeapSort(RecType R[], int n)
{
    int i;
    RecType temp;
    for (i = n / 2; i >= 1; i--)
    {
        sift(R, i, n);
    }
    for (i = n; i >= 2; i--)//进行n-1次循环，完成堆排序
    {
        temp = R[1];      //将第一个元素同当前区间内R[1]对换
        R[1] = R[i];
        R[i] = temp;
        sift(R, 1, i - 1);  //筛选R[1]结点,得到i-1个结点的堆

    }
}
int main(void)
{
    int i, n = 10;
    RecType R[MAXSIZE];
    KeyType a[] = { 0, 6, 8, 7, 9, 0, 1, 3, 2, 4, 5 };//a[0]空闲，不作为关键字
    for (i = 1; i <= n; i++)
    {
        R[i].key = a[i];
    }
    printf("排序前:");
    for (i = 1; i <= n; i++)
    {
        printf("%d ", R[i].key);
    }
    printf("\n");
    HeapSort(R, n);
    printf("排序后:");
    for (i = 1; i <= n; i++)
    {
        printf("%d ", R[i].key);
    }
    printf("\n");
    system("pause");
    return 0;
}

参考方法：
首先原始数据：
假设共有N个节点，之后便要进行N/2次的建堆：
大根堆建成后：
之后进行N-1次的根节点与最后一个节点交换：
每次交换后，除了交换后的最后一个节点以及它后面的节点（第一次节点1与节点n交换，第二次节点1与节点n-1交换。。。。直到节点1与节点2交换）如果不满足大根堆时，就要继续进行建堆！

---

直接选择排序简介及其代码

直接选择排序没有什么好说的，直接上代码：

#include <stdio.h>
#define MaxSize 20
typedef int KeyType;    //定义关键字类型
typedef char InfoType[10];
typedef struct          //记录类型
{
    KeyType key;        //关键字项
    InfoType data;      //其他数据项,类型为InfoType
} RecType;              //排序的记录类型定义
void SelectSort(RecType R[],int n)
{
    int i,j,k,l;
    RecType temp;
    for (i=0; i<n-1; i++)           //做第i趟排序
    {
        k=i;
        for (j=i+1; j<n; j++)   //在当前无序区R[i..n-1]中选key最小的R[k]
            if (R[j].key<R[k].key)
                k=j;            //k记下目前找到的最小关键字所在的位置
        if (k!=i)               //交换R[i]和R[k]
        {
            temp=R[i];
            R[i]=R[k];
            R[k]=temp;
        }
        printf("i=%d: ",i);
        for (l=0; l<n; l++)
            printf("%d ",R[l].key);
        printf("\n");
    }
}
int main()
{
    int i,n=10;
    RecType R[MaxSize];
    KeyType a[]= {9,8,7,6,5,4,3,2,1,0};
    for (i=0; i<n; i++)
        R[i].key=a[i];
    printf("排序前:");
    for (i=0; i<n; i++)
        printf("%d ",R[i].key);
    printf("\n");
    SelectSort(R,n);
    printf("排序后:");
    for (i=0; i<n; i++)
        printf("%d ",R[i].key);
    printf("\n");
    return 0;
}

---

选择排序总结

1、 简单选择排序：

① 思想：第一趟时，从第一个记录开始，通过n – 1次关键字的比较，从n个记录中选出关键字最小的记录，并和第一个记录进行交换。第二趟从第二个记录开始，选择最小的和第二个记录交换。以此类推，直至全部排序完毕。

② 时间复杂度：T(n) = O(n²)。

③ 空间复杂度：S(n) = O(1)。

④ 稳定性：不稳定排序，{3， 3， 2}。

2、 堆排序：

① 思想：把待排序记录的关键字存放在数组r[1…n]中，将r看成是一刻完全二叉树的顺序表示，每个节点表示一个记录，第一个记录r[1]作为二叉树的根，一下个记录r[2…n]依次逐层从左到右顺序排列，任意节点r[i]的左孩子是r[2i]，右孩子是r[2i+1]，双亲是r[i/2向下取整]。然后对这棵完全二叉树进行调整建堆。

② 时间复杂度：T(n) = O(n㏒n)。

③ 空间复杂度：S(n) = O(1)。

④ 稳定性：不稳定排序。{5， 5， 3}