数据结构之排序--选择类排序

三 选择类排序

    基本思想：从待排数列中选出最小的记录，放到已排好序的元素之后，直至所有元素排序完毕！

1. 直接选择排序

   初始时：有序区为空，无序区即待排数列

   第一趟，从无序区中选出最小的，与无序区的第一个元素交换。新的有序区多一个元素，新的无序区少一个元素，有序区在无序区之前！

   第二趟，......

    ............

#define SWAP(a, b) \
    do {typeof(a) tmp; tmp = (a); (a) = (b); (b) = tmp;}while(0)

void select_sort(int a[], int len)
{
    int i, j;
    int minindex;

    for (i = 0; i < len; i++) {           // 从无序区中选出最小的元素与第一个元素交换！
        minindex = i;
        for(j = i + 1; j < len; j++) {
            if (a[minindex] > a[j])
                minindex = j;
        }   

        if (i != minindex)
            SWAP(a[i], a[minindex]);
    }   

}

直接选择排序是不稳定的，如{2, 2, 1}

时间复杂度为:O(n^2); 如：第i趟选出最小的元素需要进行n - i 次比较。总的比较次数为：n * (n - 1) / 2, 平均时间复杂度为O(n^2)

2. 堆排序

大根堆：根节点的值比其左右孩子的值大的二叉树。

在堆排序中并没有用这种树形结构存储数据（二叉树本身的存储方式就有“数组，即线性表“方式），只是借用根节点与左右孩子的关系！ 即此堆是由待排数列推出来的！

leftchild = i *2; rightchild = i * 2 + 1; (i = 1, 2, 3,....), 且能推出最大的非叶子节点的编号是 size / 2;

堆排序有两个问题需要解决：

     a> 如何建堆！     //待排数列本身就是一个“二叉树”， 把它调整成堆即可！从编号最大的非叶子节点入手调整！

     b> 如何调整堆!    //根与左右孩子的大小关系，满足堆的定义

#include <stdio.h>

#define SWAP(a, b) \
    do {typeof(a) tmp; tmp = (a); (a) = (b); (b) = tmp; } while(0)

void HeapAdjust(int *a, int i, int size)  //调整堆
{
    int lchild = 2 * i;   //i的左孩子节点序号
    int rchild = 2 * i + 1;   //i的右孩子节点序号
    int max = i;

    if (i <= size / 2) {
        if (lchild <= size && a[lchild] > a[max])
            max = lchild;
        if (rchild <= size && a[rchild] > a[max])
            max = rchild;
        if (max != i) {
            SWAP(a[i], a[max]);
            HeapAdjust(a, max, size);
        }
    }

    return ;
}

void BuildHeap(int *a, int size)
{
    int i;
    for ( i = size / 2; i >= 1; i--) //非叶子节点的最大序号值是size / 2
        HeapAdjust(a, i, size);
}

void HeapSort(int a[], int size)
{
    int i;
    BuildHeap(a, size);

    for (i = size; i >= 1; i--) {
        SWAP(a[1], a[i]);   //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面
        HeapAdjust(a, 1, i - 1);  // 重新调整堆顶节点成为大顶堆， 且最后一个元素不再参与调整

    }
}

int main()
{
    int a[] = {0,16,20,3,11,17,8};
    int size = 7;
    int i;

    for (i = 0; i < size; i++)
        printf("%d  ", a[i]);
    printf("\n");

    HeapSort(a, size);

    for (i = 0; i < size; i++)
        printf("%d  ", a[i]);
    printf("\n");

    return 0;
}

注：堆排序是不稳定排序，其最坏时间复杂度为O(nlgn).堆排序的平均性能接近最坏性能，且建初始堆需要比较的次数较多，故适合元素较少的数列（记录较少的文件）！