常见排序算法——选择排序

基本思想：
每一趟(第i趟，i=0,1，…，n-2)在后面n-i个待排序的数据元素集合中选
出关键码最小的数据元素，作为有序元素序列的第i个元素。待到第n-2趟
做完，待排序元素集合中只剩下1个元素，排序结束
【直接选择排序】
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中
的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，
重复上述步骤，直到集合剩余1个元素

直接选择排序的时间复杂度为O(n^2 )；它是一种不稳定的排序算法

每次只能标记一个最大的元素，效率比较低

void SelectSort(int* array, int size)
{
    int i = 0;
    for (i = 0; i < size; ++i)
    {
        int MaxPos = 0;
        int j = 0;
        for (j = 1; j < size - i; ++j)
        {
            if (array[j] > array[MaxPos])
                MaxPos = j;
        }
        if (MaxPos != size - 1 - i)
            Swap(&array[MaxPos], &array[size - 1 - i]);
    }
}

优化后的选择排序：
每次可以标记两个元素，一个最大的元素和一个最小的元素，效率相对能高点

void SelectSort_OP(int* array, int size)
{
    int begin = 0;
    int end = size - 1;

    while (begin < end)
    {
        int MaxPos = begin;
        int MinPos = begin; 
        int j = begin + 1;

        while (j <= end)
        {
            if (array[j] > array[MaxPos])
                MaxPos = j;

            if (array[j] < array[MinPos])
                MinPos = j;

            ++j;
        }
        if (MaxPos != end)
            Swap(&array[MaxPos], &array[end]);

        if (MinPos == end)
            MinPos = MaxPos;

        if (MinPos != end)
            Swap(&array[MinPos], &array[begin]);

        ++begin;
        --end;
    }
}

【堆排序算法】
创建堆：升序—>大堆，降序—>小堆

执行如下步骤，直到数组为空
(1)把堆顶array[0]元素和当前最堆的最后一个元素交换
(2)堆元素个数减1
(3)由于第1步后根节点不再满足最堆定义，向下调整根结点

把一棵完全二叉树调整为堆，以及每次将堆顶元素交换后
进行调整的时间复杂度均为O( log2n)，所以,
堆排序的时间复杂度为：O( n * log2n)
堆排序是一种不稳定的排序算法

void HeapSort(int* array, int size) //升序，需要用大堆
{

    //创建堆
    CreatHeap(array, size);
    while (size > 0)
    {
        //交换堆顶元素和最后一个元素
        Swap(&array[0], &array[size - 1]);
        //交换后不满足堆的性质，重新调整
        AdjustHeap(array, size, 0);
    }
}

void CreatHeap(int* array, int size)
{
    int i = 0;
    for (i = size; i >= 0; i--)
        AdjustHeap(array, size, i);
}

void AdjustHeap(int* array, int size, int parent)
{
    int Lchild = 2 * parent + 1;
    int Rchild = 2 * parent + 2;

    int Max = parent;

    //若左孩子大于双亲节点，就把左孩子标记为最大节点
    if (Lchild <= size && array[parent] < array[Lchild])
        Max = Lchild;

    //若右孩子大于双亲节点，就把右孩子标记为最大节点
    if (Rchild <= size && array[Max] < array[Rchild])
        Max = Rchild;

    //若最大节点不是双亲节点，那就将双亲节点和最大节点进行交换，继续调整
    if (Max != parent)
    {
        Swap(&array[Max], &array[parent]);
        AdjustHeap(array, size, Max);
    }

}

交换函数

void Swap(int* pLeft, int* pRight)
{
    int tmp;
    assert(pLeft);
    assert(pRight);

    tmp = *pLeft;
    *pLeft = *pRight;
    *pRight = tmp;
}

打印函数

void print(int* array, int size)
{
    int i = 0;
    for (i = 0; i < size; ++i)
        printf("%d ", array[i]);
    printf("\n");
}

测试函数 test.c

#include "SelectSort.h"

int main()
{
    int array[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
    int size = sizeof(array) / sizeof(array[0]);

    //选择排序
    //SelectSort(array, size);

    //SelectSort_OP(array, size);

    //堆排序
    HeapSort(array, size);
    print(array, size);

    system("pause");
    return 0;
}

常见排序算法——选择排序

猜你喜欢