【数据结构】排序算法之选择排序

一、选择排序——最差的排序算法
在选择排序中，假定我们需要升序，因此在每次排序中，需要找到最大的元素，将其放在最后，在每一次的循环中，都是将最大的元素放在最后，因此对于数据较多的数组，循环的次数将与数组中元素的个数一致，因此，在对于这种数组进行排序时，将十分的浪费时间。
有关选择排序的思路，如下所示：
（一）方式一，默认数组中最后一个元素最大，如下图所示：

代码如下所示：

void SelectSort(int *array, int size)
{
    assert(array || size < 0);
    int i = 0;
    int j = 0;
    int maxPos = 0;
    for (; i < size - 1; ++i)
    {
        maxPos = size - i - 1;//记录最大的元素,默认最后一个元素最大
        for (j = 0; j < size - i; ++j)
        {
            //找到最大的元素
            if (array[j]>array[maxPos])
            {
                maxPos = j;
            }
        }
        //将最大的元素与最后一个元素进行交换
        swap(array[maxPos], array[size - i - 1]);
    }
}

（二）方式二——利用前后指针的做法，在一趟排序中，一次全都将最大值与最小值找出来，最大值放在数组的最后，最小值放在数组的前面，然后分别改变两个指针的指向，直到两个指针相遇为止。

排序代码如下所示：

void SelectSort_OP(int *array, int size)
{
    assert(array || size < 0);
    int i = 0;
    int begin = 0;
    int end = size - 1;
    while (begin < end)
    {
        int minPos = begin;
        int maxPos = end;
        for (i = begin; i <= end; ++i)
        {
            //找最大与最小元素
            if (array[i]>array[maxPos])
            {
                maxPos = i;
            }

            if (array[i] < array[minPos])
            {
                minPos = i;
            }
        }
        //交换元素
        if (minPos != begin)
        {
            swap(array[minPos], array[begin]);
        }
        //防止在开始与结束分别出现最大与最小元素
        if (maxPos == begin)
        {
            maxPos = minPos;
        }


        if (maxPos != end)
        {
            swap(array[maxPos], array[end]);
        }
        begin++;
        end--;
    }
}

结果如下所示：

二、堆排序
要利用堆排序，首先要创建一个堆，这样才能进行堆排序
大堆——-升序
小堆- —–降序

实现如下所示：

void HeapAdjust(int*array, int size, int parent)
{
    //默认左孩子最大
    int child = parent * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size&&array[child] < array[child + 1])
        {
            //右孩子较大
            child += 1;
        }

        if (array[parent] < array[child])
        {
            swap(array[parent], array[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else//已经是大堆，不需要调整
            break;
    }
}
void HeapSort(int *array, int size)
{
    assert(array || size < 0);
    //建堆
    int root = (size - 2) >> 1;//找到倒数第一个非叶子节点
    for (; root>=0; --root)//此处大于等于0，是为了一直调整到堆顶元素
        HeapAdjust(array, size, root);
    //排序
    int end = size - 1;
    while (end > 0)//直到数组中只剩一个元素，则不需要在调整
    {
        swap(array[0], array[end]);
        HeapAdjust(array, end, 0);
        --end;
    }


}

结果如下所示：

有关选择排序的内容就这么多了，希望大家一起进步！！！！

只有不停的奔跑，才能不停留在原地！！！