黑马程序员--冒泡排序法

                                                                          ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

                                                                             

 一.冒泡排序：

        冒泡排序的的优点是好理解，稳定，再就是空间复杂度低，不需要额外开辟数组元素的临时保存控件，当然了，编写起来也容易。其算法很简单，就是比较数组相邻的两个值，把大的像泡泡一样“冒”到数组后面去，一共要执行N的平方除以2这么多次的比较和交换的操作（N为数组元素），其复杂度为Ο(n²)，如图：

                                                              

冒泡排序是非常容易理解和实现，，以从小到大排序举例：

设数组长度为N。

1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。

2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。

3．N=N-1，如果N不为0就重复前面二步，否则排序完成

[cpp] view plaincopy

1. main()  
2. {  
3.     int a[5];  
4.     int i;  
5.     int j;  
6.     int k;  
7.     int temp;  
8.     for(k=0;k<5;k++)  
9.         scanf("%d",&a[k]);  
10.     for (i=0;i<5;i++)  
11.         for (j=0;j<5-i;j++)  
12.         {  
13.             if (a[j]>a[j+1])  
14.             {  
15.                 temp=a[j+1];  
16.                 a[j+1]=a[j];  
17.                 a[j]=temp;  
18.             }  
19.         }  
20.         for (i=0;i<5;i++)  
21.         {  
22.             printf("%d ",a[i]);  
23.         }  
24. }  

二.选择排序：

        自己能够想得出来的排序法，思路很简单，用打擂台的方式，找出最大的一个元素，和末尾的元素交换，然后再从头开始，查找第1 个到第N-1 个元素中最大的一个，和第N-1 个元素交换……其实差不多就是冒泡法的思想，但整个过程中需要移动的元素比冒泡法要少，因此性能是比冒泡法优秀的。看图：

                                                                   

[cpp] view plaincopy

1. void select_sort(int a[],int len)  
2. {  
3.     int i,j,x,l;  
4.     for(i=0;i<len;i++)  
5.     {  
6.         x=a[i];  
7.         l=i;  
8.         for(j=i;j<len;j++)  
9.         {  
10.             if(a[j]<x)  
11.             {  
12.                 x=a[j];  
13.                 l=j;  
14.             }  
15.         }  
16.         a[l]=a[i];  
17.         a[i]=x;  
18.     }  
19. }  

                                                                          ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------