C语言冒泡排序法和选择排序法的区别



冒泡排序法：

#define _CRT_SECURE_NO_WARNINGS 1  
2.#include  
3.#include  
4.#include  
5.void rank(int arr[], int len)  
6.{  
7.    int i = 0;  
8.    int j = 0;  
9.    int temp = 0;  
10.    for (i = 0; i < len-1; i++)  
11.    {  
12.        for (j = 0; j < len-1- i; j++)  
13.        {  
14.            if (arr[j] < arr[j+1])  
15.            {  
16.                temp = arr[j];  
17.                arr[j] = arr[j+1];  
18.                arr[j+1] = temp;  
19.            }  
20.        }  
21.    }  
22.}  
23.int main()  
24.{   
25.    int array[9] = { 9, 8, 7, 4, 16, 5, 6, 3, 1 };  
26.    int len = sizeof(array) / sizeof(array[0]);  
27.    int i = 0;  
28.    rank(array, len);  
29.    for (i = 0; i < len; i++)  
30.    {  
31.        printf("%d", array[i]);  
32.        printf(" ");  
33.    }  
34.    system("pause");  
35.    return 0;  
36.}  

选择排序法：

#define _CRT_SECURE_NO_WARNINGS 1  
2.#include  
3.#include  
4.#include  
5.void rank(int arr[], int len)  
6.{      
7.    assert(arr);  
8.    assert(len);  
9.    int i = 0;  
10.    int j = 0;  
11.    int temp = 0;  
12.    for (i = 0; i < len-1; i++)  
13.    {  
14.        for (j =i+1; j < len; j++)  
15.        {  
16.            if (arr[i] < arr[j])  
17.            {  
18.                temp = arr[i];  
19.                arr[i] = arr[j];  
20.                arr[j] = temp;  
21.            }  
22.        }  
23.    }  
24.}  
25.int main()  
26.{   
27.    int array[9] = { 9, 8, 7, 4, 16, 5, 6, 3, 1 };  
28.    int len = sizeof(array) / sizeof(array[0]);  
29.    int i = 0;  
30.    rank(array, len);  
31.    for (i = 0; i < len; i++)  
32.    {  
33.        printf("%d", array[i]);  
34.        printf(" ");  
35.    }  
36.    system("pause");  
37.    return 0;  
38.}  

选择排序法和冒泡排序法的区别：

冒泡排序法：一趟一趟的将两个相邻的数进行交换如果有10个数则需要排9躺，如果是从大到小输出则需要每次将后一个数和前一个数进行比较将较大的数赋值给钱一个数，将较小的数赋值给后一个数，其实就是两个数交换，那么第一趟交换完毕后，最小的数便出现在了数组的最后面，然后进行第二趟的比较时则要对余下的前9个数进行比较，9趟比较完成后则数组也已经排好序。

选择排序法：10个数则是需要排9次，若按降序排列，第一次比较：则是将数组的第一个元素与数组中从第二个元素开始到最后的元素进行比较找到最大的数记录下来然后将值赋值给数组的第一个元素，然后进行第二次比较：则是将数组的第二个元素与数组中从第三个元素开始到最后的元素进行比较，找最大的数记录下来将值赋值给数组的第二个元素。。。依次循环找完

转载自：https://blog.csdn.net/persistence_s/article/details/53200421