C 语言直接选择排序代码

选择排序中心思想：

每次从无序的队列中，选择出最大（最小）的值，排到有序队列的队尾，并将该值从无序队列中移除。
实现时，在不考虑空间的情况下，可以申请和无序队列一样大小的空间并初始化，然后按照上述的思想将无序队列中的值一个接一个放到该空间上形成有序队列。这种操作是可以实现直接选择排序，但是在内存空间的考量上是不合适的。为了节约内存空间，可以先在无序队列中找到最大（最小）值的下标，然后将这个下标所对应的值和无序队列队首的值进行交换。这样，每次从无序队列中选出最大（小）的值，和无序队列队首的值进行交换。依次下去，就完成排序。

代码实现

以下两种写法，第一种几乎完全拷贝自冒泡排序，两两比较，两两交换，并记录最大（小）值的下标，这样写法，其实非常不好。第二种则做了优化，每次比较，只找出最大（最下）值的下标，比较结束，再做交换。

/*
 @function: select_sort
 @functional: select sort
 @order for parameter value, 1 is ascending and 0 is descending
 */
static int select_sort_one(int order)
{
    int arry[] = {12, 13, 5, 3, 14, 90, 0, 11, 23, 9, 15, 99, 100, 96};
    int number_of_times = 0;
    int i = 0, j = 0, temp = 0, arry_index = 0;

    for(i = 0; i < sizeof(arry)/sizeof(arry[0]); i++)
        printf("%d ", arry[i]);
    printf("\n");

    for (i = 0; i < sizeof(arry)/sizeof(arry[0])-1; i++) {
        temp = arry[i];
        arry_index = i;
        for (j = i; j < sizeof(arry)/sizeof(arry[0]); j++) {
            if (arry[i] > arry[j]) {
                arry[i] =  arry[j];
                arry_index = j;
            }
            number_of_times ++;
        }
        arry[arry_index] = temp;
    }
    for(i = 0; i < sizeof(arry)/sizeof(arry[0]); i++)
        printf("%d ", arry[i]);
    printf("\n");
    printf("%s: number of times = %d\n\n",__func__, number_of_times);

    return 0;
}


/*
 @function: select_sort
 @functional: select sort
 @order for parameter value, 1 is ascending and 0 is descending
 */
static int select_sort_two(int order)
{

    int arry[] = {12, 13, 5, 3, 14, 90, 0, 11, 23, 9, 15, 99, 100, 96};
    int number_of_times = 0;
    int i = 0, j = 0;

    for(i = 0; i < sizeof(arry)/sizeof(arry[0]); i++)
        printf("%d ", arry[i]);
    printf("\n");

    if (order == 1) { /*ascending order*/
        for (i = 0; i < sizeof(arry)/sizeof(arry[0])-1; i++) {
            int min_index = i;
            for (j = i; j < sizeof(arry)/sizeof(arry[0]); j++) {
                if (arry[min_index] > arry[j]) {
                    min_index = j;
                }
                number_of_times ++;
            }
            if (min_index != i) {
                int temp = arry[i];
                arry[i] = arry[min_index];
                arry[min_index] = temp;
            }
        }
    } else if (order == 0) { /*descending order*/
        for (i = 0; i < sizeof(arry)/sizeof(arry[0])-1; i++) {
            int max_index = i;
            for (j = i; j < sizeof(arry)/sizeof(arry[0]); j++) {
                if (arry[max_index] < arry[j]) {
                    max_index = j;
                }
                number_of_times ++;
            }
            if (max_index != i) {
                int temp = arry[i];
                arry[i] = arry[max_index];
                arry[max_index] = temp;
            }
        }
    }
    for(i = 0; i < sizeof(arry)/sizeof(arry[0]); i++)
        printf("%d ", arry[i]);
    printf("\n");
    printf("%s: number of times = %d\n\n",__func__, number_of_times);

    return 0;
}

int main(void)
{
    select_sort_one(1);
    select_sort_two(1);
    return 0;
}

运行结果

./a.out
12 13 5 3 14 90 0 11 23 9 15 99 100 96
0 3 5 9 11 12 13 14 15 23 90 96 99 100
select_sort_one: number of times = 104

12 13 5 3 14 90 0 11 23 9 15 99 100 96
0 3 5 9 11 12 13 14 15 23 90 96 99 100
select_sort_two: number of times = 104

和冒泡算法的比较

1.时间复杂度：冒泡和直接选择排序都是 O(n*n)
2.冒泡排序是两两比较，并依次交换；直接选择排序，两两比较，记录最大（小）值的下标，一趟完毕，再做交换，交换次数较少。