5.冒泡排序

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）实例：

spacer.gif


（3）用java实现

1.publicclass bubbleSort { 
2.public bubbleSort(){ 
3.int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
4.int temp=0; 
5.for(int i=0;i<a.length-1;i++){ 
6.for(int j=0;j<a.length-1-i;j++){ 
7.if(a[j]>a[j+1]){ 
8.      temp=a[j]; 
9.      a[j]=a[j+1]; 
10.      a[j+1]=temp; 
11.    } 
12.    } 
13.  } 
14.for(int i=0;i<a.length;i++) 
15.  System.out.println(a[i]);   
16.} 
17.} 
18.

6.快速排序


（1）基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

（2）实例：

spacer.gif


（3）用java实现

1.publicclass quickSort { 
2.int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
3.public quickSort(){ 
4.  quick(a); 
5.for(int i=0;i<a.length;i++) 
6.    System.out.println(a[i]); 
7.} 
8.publicint getMiddle(int[] list, int low, int high) {   
9.int tmp = list[low];  //数组的第一个作为中轴
10.while (low < high) {   
11.while (low < high && list[high] >= tmp) {   
12.
13.   high--;   
14.        }   
15.        list[low] = list[high];  //比中轴小的记录移到低端
16.while (low < high && list[low] <= tmp) {   
17.          low++;   
18.        }   
19.        list[high] = list[low];  //比中轴大的记录移到高端
20.      }   
21.      list[low] = tmp;       //中轴记录到尾
22.return low;          //返回中轴的位置
23.    }  
24.publicvoid _quickSort(int[] list, int low, int high) {   
25.if (low < high) {   
26.int middle = getMiddle(list, low, high); //将list数组进行一分为二
27.        _quickSort(list, low, middle - 1);    //对低字表进行递归排序
28.        _quickSort(list, middle + 1, high);    //对高字表进行递归排序
29.      }   
30.    }  
31.publicvoid quick(int[] a2) {   
32.if (a2.length > 0) {  //查看数组是否为空
33.        _quickSort(a2, 0, a2.length - 1);   
34.    }   
35.    }  
36.}

7、归并排序

（1）基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

（2）实例：

spacer.gif


（3）用java实现

1.import java.util.Arrays; 
2.
3.publicclass mergingSort { 
4.int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 
5.public mergingSort(){ 
6.  sort(a,0,a.length-1); 
7.for(int i=0;i<a.length;i++) 
8.    System.out.println(a[i]); 
9.} 
10.publicvoid sort(int[] data, int left, int right) { 
11.// TODO Auto-generated method stub 
12.if(left<right){ 
13.//找出中间索引 
14.int center=(left+right)/2; 
15.//对左边数组进行递归 
16.    sort(data,left,center); 
17.//对右边数组进行递归 
18.    sort(data,center+1,right); 
19.//合并 
20.    merge(data,left,center,right); 
21.
22.  } 
23.} 
24.publicvoid merge(int[] data, int left, int center, int right) { 
25.// TODO Auto-generated method stub 
26.int [] tmpArr=newint[data.length]; 
27.int mid=center+1; 
28.//third记录中间数组的索引 
29.int third=left; 
30.int tmp=left; 
31.while(left<=center&&mid<=right){ 
32.
33.//从两个数组中取出最小的放入中间数组 
34.if(data[left]<=data[mid]){ 
35.      tmpArr[third++]=data[left++]; 
36.    }else{ 
37.      tmpArr[third++]=data[mid++]; 
38.    } 
39.  } 
40.//剩余部分依次放入中间数组 
41.while(mid<=right){ 
42.    tmpArr[third++]=data[mid++]; 
43.  } 
44.while(left<=center){ 
45.    tmpArr[third++]=data[left++]; 
46.  } 
47.//将中间数组中的内容复制回原数组 
48.while(tmp<=right){ 
49.    data[tmp]=tmpArr[tmp++]; 
50.  } 
51.  System.out.println(Arrays.toString(data)); 
52.} 
53.
54.}

8、基数排序

（1）基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

（2）实例：

spacer.gif


（3）用java实现

1.import java.util.ArrayList; 
2.import java.util.List; 
3.
4.publicclass radixSort { 
5.int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51}; 
6.public radixSort(){ 
7.  sort(a); 
8.for(int i=0;i<a.length;i++) 
9.    System.out.println(a[i]); 
10.} 
11.publicvoid sort(int[] array){   
12.
13.//首先确定排序的趟数;    
14.int max=array[0];   
15.for(int i=1;i<array.length;i++){   
16.if(array[i]>max){   
17.        max=array[i];   
18.        }   
19.      }   
20.
21.int time=0;   
22.//判断位数;    
23.while(max>0){   
24.        max/=10;   
25.        time++;   
26.      }   
27.
28.//建立10个队列;    
29.      List<ArrayList> queue=new ArrayList<ArrayList>();   
30.for(int i=0;i<10;i++){   
31.        ArrayList<Integer> queue1=new ArrayList<Integer>();  
32.        queue.add(queue1);   
33.    }   
34.
35.//进行time次分配和收集;    
36.for(int i=0;i<time;i++){   
37.
38.//分配数组元素;    
39.for(int j=0;j<array.length;j++){   
40.//得到数字的第time+1位数;  
41.int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i); 
42.          ArrayList<Integer> queue2=queue.get(x); 
43.          queue2.add(array[j]); 
44.          queue.set(x, queue2); 
45.      }   
46.int count=0;//元素计数器;    
47.//收集队列元素;    
48.for(int k=0;k<10;k++){  
49.while(queue.get(k).size()>0){ 
50.          ArrayList<Integer> queue3=queue.get(k); 
51.            array[count]=queue3.get(0);   
52.            queue3.remove(0); 
53.          count++; 
54.       }   
55.      }   
56.     }   
57.
58.  }  
59.
60.}