简单选择排序（Simple Select Sort）

最新推荐文章于 2022-03-20 23:22:29 发布

test1280

最新推荐文章于 2022-03-20 23:22:29 发布

阅读量622

点赞数

分类专栏： C-C++ 算法文章标签：排序算法简单选择排序

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/test1280/article/details/70183256

版权

C-C++ 同时被 2 个专栏收录

97 篇文章 7 订阅

订阅专栏

算法

17 篇文章 0 订阅

订阅专栏

简单选择排序（Simple Select Sort）

简单选择排序是入门级别的排序算法，算法易懂，实现简单。

假设现在有一个待排序序列，长度是n，要求从小到大排序。

简单选择排序将要进行n-1次外循环（不需要进行n次，因为n个元素中已经有n-1个是确定了的，最后一个当然也是确定了的），在每次外循环中选择一个最小的/最大的放置在当前选择范围的最左边/最右边。

在第0次外循环时，内循环选择位置0至位置n-1的（共n个数字）最小的数字放置在位置0处；

在第1次外循环时，内循环选择位置1至位置n-1的（共n-1个数字）最小的数字放置在位置1处；

……

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {   
        printf("%d ", parray[i]);   
    }   
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i, j;
    int minIdx;
    int tmp;
    for (i=0; i<n-1; i++)
    {
        minIdx = i;

        printf("----------------------------------\n");
        printf("before swap:minIdx=%d, i=%d\narray:\n", minIdx, i);
        print_array(parray, 8);

        for (j=i+1; j<n; j++)
        {
            if (parray[minIdx]>parray[j])
            {
                minIdx = j;
            }
        }
        if (i!=minIdx)
        {
            tmp = parray[i];
            parray[i] = parray[minIdx];
            parray[minIdx] = tmp;
        }
        printf("after swap:minIdx=%d, i=%d\narray:\n", minIdx, i);
        print_array(parray, 8);
        printf("----------------------------------\n\n");
    }
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

输出如下：

[test1280@localhost sort]$ ./main 
49 38 65 97 76 13 27 49 
----------------------------------
before swap:minIdx=0, i=0
array:
49 38 65 97 76 13 27 49 
after swap:minIdx=5, i=0
array:
13 38 65 97 76 49 27 49 
----------------------------------

----------------------------------
before swap:minIdx=1, i=1
array:
13 38 65 97 76 49 27 49 
after swap:minIdx=6, i=1
array:
13 27 65 97 76 49 38 49 
----------------------------------

----------------------------------
before swap:minIdx=2, i=2
array:
13 27 65 97 76 49 38 49 
after swap:minIdx=6, i=2
array:
13 27 38 97 76 49 65 49 
----------------------------------

----------------------------------
before swap:minIdx=3, i=3
array:
13 27 38 97 76 49 65 49 
after swap:minIdx=5, i=3
array:
13 27 38 49 76 97 65 49 
----------------------------------

----------------------------------
before swap:minIdx=4, i=4
array:
13 27 38 49 76 97 65 49 
after swap:minIdx=7, i=4
array:
13 27 38 49 49 97 65 76 
----------------------------------

----------------------------------
before swap:minIdx=5, i=5
array:
13 27 38 49 49 97 65 76 
after swap:minIdx=6, i=5
array:
13 27 38 49 49 65 97 76 
----------------------------------

----------------------------------
before swap:minIdx=6, i=6
array:
13 27 38 49 49 65 97 76 
after swap:minIdx=7, i=6
array:
13 27 38 49 49 65 76 97 
----------------------------------

13 27 38 49 49 65 76 97 
[test1280@localhost sort]$

示意图：

49 38 65 97 76 13 27 49 中最小的是13，那么把13的下标记录下来，到最后和最初的下标值比较，如果不相等，那么就交换两个元素。

注意下，对比冒泡排序，当待排序序列中每个对象比较复杂的时候，显然以简单选择排序，可以减少很多不必要的构造函数的调用，效率会高很多。

交换后为：

13 38 65 97 76 49 27 49

这样，13一定是最后排好序中最小的那个，位置已经确定。

现在继续从位置1处到位置n-1处的n-1个数字排序：

最小的是27，

13 38 65 97 76 49 27 49

最后发现初始minIdx是1，最小值的下标是6，进行交换：

13 27 65 97 76 49 38 49

以此类推。

也可以将大数放置在右侧，如下：

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {
        printf("%d ", parray[i]);
    }
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i, j;
    int maxIdx;
    int tmp;
    for (i=n-1; i>0; i--)
    {
        maxIdx = i;

        printf("----------------------------------\n");
        printf("before swap:maxIdx=%d, i=%d\narray:\n", maxIdx, i);
        print_array(parray, 8);

        for (j=0; j<i; j++)
        {
            if (parray[maxIdx]<parray[j])
            {
                maxIdx = j;
            }
        }
        if (i!=maxIdx)
        {
            tmp = parray[i];
            parray[i] = parray[maxIdx];
            parray[maxIdx] = tmp;
        }
        printf("after swap:maxIdx=%d, i=%d\narray:\n", maxIdx, i);
        print_array(parray, 8);
        printf("----------------------------------\n\n");
    }
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

输出如下：

[test1280@localhost sort]$ ./main
49 38 65 97 76 13 27 49 
----------------------------------
before swap:maxIdx=7, i=7
array:
49 38 65 97 76 13 27 49 
after swap:maxIdx=3, i=7
array:
49 38 65 49 76 13 27 97 
----------------------------------

----------------------------------
before swap:maxIdx=6, i=6
array:
49 38 65 49 76 13 27 97 
after swap:maxIdx=4, i=6
array:
49 38 65 49 27 13 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=5, i=5
array:
49 38 65 49 27 13 76 97 
after swap:maxIdx=2, i=5
array:
49 38 13 49 27 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=4, i=4
array:
49 38 13 49 27 65 76 97 
after swap:maxIdx=0, i=4
array:
27 38 13 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=3, i=3
array:
27 38 13 49 49 65 76 97 
after swap:maxIdx=3, i=3
array:
27 38 13 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=2, i=2
array:
27 38 13 49 49 65 76 97 
after swap:maxIdx=1, i=2
array:
27 13 38 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=1, i=1
array:
27 13 38 49 49 65 76 97 
after swap:maxIdx=0, i=1
array:
13 27 38 49 49 65 76 97 
----------------------------------

13 27 38 49 49 65 76 97 
[test1280@localhost sort]$

区别不是很大，不再赘述。

忽然想起来昨天的快速排序，是分治+挖坑填坑来做的，那能不能用分治到这里的简单选择排序呢？

递归版简单选择排序：

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {   
        printf("%d ", parray[i]);   
    }   
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i;
    int maxIdx = n-1;
    for (i=0; i<n-1; i++)
    {
        if (parray[i]>parray[maxIdx])
        {
            maxIdx = i;
        }
    }
    if (maxIdx != (n-1))
    {
        int tmp = parray[n-1];
        parray[n-1] = parray[maxIdx];
        parray[maxIdx] = tmp;
    }
    if (n==2)
        return;
    selectSort(parray, n-1);
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

一开始写的时候直接错了……原来忘记了递归结束的条件。。。切记加上递归结束的条件。

当待排序数组为2时，排序完毕后已经不需要再排序了。

Over。