数据结构之——选择排序

　　选择排序的基本思想为：每一趟（例如第i趟）在后面的n-i+1（i=1,2,3，…...，n-1）个待排序元素中选取关键字最小的元素，作为有序序列的第i个元素，直到n-1趟做完，待排序元素只剩下一个，就不用选了，序列也排序完毕。选择排序主要有简单选择排序和堆排序，下面分别就这两种排序算法进行讨论。

1.简单选择排序

         从上面选择排序的思想中可以很直观的得出简单选择排序的算法思想：假设排序列表为L[1……n]，第i趟排序从L[i……n]中选择关键字最小的元素与L(i)交换，每一趟排序可以确定一个元素的最终位置，这样经过n-1排序就可以使得整个列表有序。

具体实现的代码如下：

#include<iostream>
using namespace std;

//声明打印辅助函数
void printArray(int array[], int length);
//声明简单选择排序函数
void SimpleSelectSort(int array[], int length);

int main()
{
    int array[] = { 12, 3, 6, 4, 27, 9 };
    int length = sizeof(array) / sizeof(*array);

    cout << "排序前序列为：" << endl;
    printArray(array, length);

    SimpleSelectSort(array, length);
    cout << endl << "简单选择排序后序列为：" << endl;
    printArray(array, length);
    cout << endl;
    system("pause");
    return 0;
}

void printArray(int array[], int length)
{
    for (int i = 0; i < length; i++)
    {
        if (i == length - 1)
            cout << array[i];
        else
            cout << array[i] << ",";
    }
}

//简单选择排序函数
void SimpleSelectSort(int array[], int length)
{
    for (int i = 0; i < length - 1;i++)
    {
        int min = i;
        for (int j = i + 1; j < length;j++)
        {
            if (array[min] > array[j])
            {
                min = j;
            }
        }
        if (min != i)
        {
            int tmp = array[min];
            array[min] = array[i];
            array[i] = tmp;
        }
    }
}

2.堆排序

堆排序中的几个操作而是解释如下：

（1）建堆

         堆排序的关键是建堆，对初始序列建堆，就是一个反复筛选的过程。n个结点的完全二叉树，最后一个结点是n/2个结点的孩子。对n/2个结点为根的子树筛选（对于大根堆：若根结点的关键字小于左右子女中的较大者，则对其进行交换），使该子树成为堆，最后依次对各结点（n/2-1~1）为根的子树进行筛选，看该结点是否大于其左右子结点的值，若不是，则将左右子结点中较大值与之交换，交换后可能破坏下一级的堆，于是继续采用上述方法构造下一级的堆，直到已该结点为根的子树构成堆为止。反复利用上述筛选策略，直到根结点。建议大家动手操作一下，加深理解。

（2）插入：先将新结点放在堆的末端，再对这个新结点执行向上调整操作。

（3）删除：先将堆的最后一个元素和堆顶元素进行交换，此时对根结点进行向下调整操作。

堆排序具体实现代码如下：

#include<iostream>
using namespace std;

/************************************************************************/
/* 本文的array中的物理位置与逻辑位置一致，0号位置留出供后序操作使用  */
/************************************************************************/

//声明打印辅助函数
void printHeapArray(int array[], int length);

//声明堆排序函数及相关辅助函数
//向上调整函数
void AdjustUp(int array[], int k);
//向下调整函数
void AdjustDown(int array[], int k, int length);
//建立大根堆函数
void BuildMaxHeap(int array[], int length);
//堆排序函数
void HeapSort(int array[], int length);

int main()
{
    int array[] = { 0, 12, 3, 6, 4, 27, 9 };
    int length = sizeof(array) / sizeof(*array) - 1;
    cout << "排序前序列为：" << endl;
    printHeapArray(array, length);

    HeapSort(array, length);
    cout << endl << "堆排序后序列为：" << endl;
    printHeapArray(array, length);
    cout << endl;
    system("pause");
    return 0;
}

void printHeapArray(int array[], int length)
{
    for (int i = 1; i <= length; i++)
    {
        if (i == length )
            cout << array[i];
        else
            cout << array[i] << ",";
    }
}

//向上调整函数
void AdjustUp(int array[], int k)
{
    //k为向上调整的结点，在这里也是堆的元素个数
    //1.array[0]存储带调整结点
    array[0] = array[k];
    int i = k / 2;
    while ((i > 0) && (array[i] < array[0]))
    {
        //2.开始交换元素
        array[k] = array[i];
        k = i;
        i = k / 2;
    }
    //3.完成元素交换
    array[k] = array[0];
}

//向下调整函数，用于插入元素
void AdjustDown(int array[], int k, int length)
{
    array[0] = array[k];
    for (int i = 2 * k; i <= length; i = i * 2)
    {
        //取k的孩子结点中key较大的元素，特别需要注意的是
        //这里if语句中一定要有i<length的判断，因为若i=length，则array[i + 1]不存在
        if (i<length && array[i] < array[i + 1])  
            i++;
        if (array[0]>array[i]) break;
        else
        {
            array[k] = array[i];
            k = i;
        }
    }
    array[k] = array[0];
}
//建立大根堆函数
void BuildMaxHeap(int array[], int length)
{
    for (int i = length / 2; i > 0; i--)
    {
        AdjustDown(array, i, length);
    }
}
//堆排序函数
void HeapSort(int array[], int length)
{
    BuildMaxHeap(array, length);
    for (int i = length; i > 1; i--)
    {
        int tmp = array[i];
        array[i] = array[1];
        array[1] = tmp;
        AdjustDown(array, 1, i - 1);
    }
}

3.杂论

（1）通常如果我们需要在一大堆元素中取k个最大或最小元素时，都优先采用堆排序。