三种基本排序-冒泡排序、直接插入排序、选择排序 

冒泡排序（从大到小）

 

       原理：对于n个数，需要进行n-1次扫描，每次扫描通过相邻两个数的比较，找出最大的数，放到数列顶部。

      程序：

    1.冒泡排序1：每次扫描把下一个元素和最前面的元素比较，一次扫描结束后，最大的元素就在最前面了。

 

view plaincopy to clipboardprint?

1. void bubble_sort1(int a[],int len)  
2. {  
3.     int i,j;  
4.     for (i=0; i<len-1; i++)  
5.     {  
6.         for (j=i+1; j<len; j++)  
7.         {  
8.             if (a[i] < a[j])  
9.             {  
10.                             /***数值交换方法3-位运算******/  
11.                 a[i]^= a[j];  
12.                 a[j]^= a[i];  
13.                 a[i]^= a[j];  
14.             }  
15.         }  
16.     }  
17. }  

 

  2.冒泡排序2：每扫描一次，通过相邻两个元素的比较，使得最小或最大的数位于顶部。

 

view plaincopy to clipboardprint?

1. void bubble_sort2(int a[],int len)  
2. {  
3.     int i,j;  
4.     for (i=0; i<len-1; i++) //扫描次数len-1   
5.     {  
6.           for (j=len-1; j>i; j--)  
7.         {  
8.            if (a[j] > a[j-1])  
9.             {  
10.                     /***数值交换方法1--加减法******  
11.              a[j]+=a[j-1];  
12.                  a[j-1] = a[j] - a[j-1];  
13.                  a[j] = a[j] - a[j-1];  
14.             }  
15.         }  
16.     }  
17. }  

 

3.冒泡排序3。对冒泡排序的改进方法：通过加入exchange变量用来判断每次扫描是否发生数值交换，如果哪次扫描没有发生数值交换，则已经排序好，无需进行下次扫描，减少了时间复杂度。

 

view plaincopy to clipboardprint?

1. void bubble_sort3(int a[],int len)  
2. {  
3.     int i,j;  
4.     int exchange = 0;     //用户标识是否发生过排序，用作冒泡的改进  
5.          int temp;  
6.     for (i=0; i<len-1; i++)    //扫描次数len - 1   
7.     {  
8.         exchange = 0;  //每次扫描前对exchange置0  
9.         for (j=len-1; j>i; j--)  
10.         {  
11.             if (a[j] > a[j-1])  
12.             {  
13.                 /***数值交换方法2--临时变量置换法******/  
14.                 temp = a[j];  
15.                 a[j] = a[j-1];  
16.                 a[j-1] = temp;  
17.                 exchange = 1;  //如果还有排序，则exchange 为1  
18.             }  
19.         }  
20.   
21.         if (exchange == 0)  //如果此次扫描没有发生过交换，则说明已经全部排序好，不需要进行下次扫描  
22.         {  
23.             return;  
24.         }  
25.     }  
26. }  

 

  以上三个简单的冒泡算法中，用了三种不同的数值交换方法:加减法、置换法、位运算法。其中位运算法效率最高。

 以上排序均为从大到小排序，若要从小到大，只做少许改动即可，原理相同！

直接插入排序

 

 

---

 

 原理：每次执行，把后面的数插入到前面已经排序好的数组中，直到最后一个完成。

view plaincopy to clipboardprint?

1. /****************直接插入排序**************/  
2. void directinsert_sort(int a[], int len)  
3. {  
4.     int i,j;  
5.     int temp;  
6.     for (i=1; i<len; i++) //  
7.     {  
8.         temp = a[i];  
9.         for (j=i-1; j>=0; j--)  
10.         {  
11.             if (temp < a[j])  //如果插入的值小于某个值，则退出循环  
12.             break;  
13.   
14.             a[j+1] = a[j];  
15.           
16.         }  
17.         a[j+1] = temp;  
18.     }  
19. }  

 

选择排序

 

 

    原理：每次从待排序的记录中选出最大的数，放入已排好序的子文件中，直到全部记录完成。

 

 

view plaincopy to clipboardprint?

1. /****************选择排序************/  
2. void select_sort(int a[], int len)  
3. {  
4.     int i,j;  
5.     int max,k;  //最大值及其下标  
6.     for (i=0; i<len-1; i++)       //遍历len-1次  
7.     {  
8.         max = a[i];               //每次遍历前max 和 k的设置  
9.         k = i;  
10.   
11.         for (j=i+1; j<len; j++)    //每次取得剩余的最大值，及其下标  
12.         {  
13.             if (a[j] > max)  
14.             {  
15.                 max = a[j];  
16.                 k = j;  
17.             }  
18.         }  
19.   
20.         a[k] = a[i];  
21.         a[i] = max;  
22.           
23.     }  
24. }  

 

 

以下为main函数及数组打印函数：

 

 

view plaincopy to clipboardprint?

1. /**********打印数组函数*************/  
2. void print_array(int a[], int len)  
3. {  
4.     for (int i=0; i<len; i++)  
5.     {  
6.         cout<<a[i]<<" ";  
7.     }  
8.     cout<<endl;  
9. }  
10.   
11. int main()  
12. {  
13.     int a[10]={3,5,7,5,2,7,8,4,1,30};  
14.     cout<<"排序前:";  
15.     print_array(a,10);  
16.   
17.     bubble_sort2(a,10);  //冒泡排序  
18. //  select_sort(a,10);   //选择排序  
19.     //directinsert_sort(a,10);//插入排序  
20.     cout<<"排序后:";  
21.     print_array(a,10);  
22.     return 0;  
23. }  

  

 

  以上三种简单排序算法，都是从大到小的排序！