各种排序算法

调换位置的静态方法：

1. public class SortUtil {    
2.     public static void swap(int a[], int i, int j) {    
3.         int tmp = a[i];    
4.         a[i] = a[j];    
5.         a[j] = tmp;    
6.     }   
7. }   

冒泡排序，快速排序，选择排序，插入排序等。

java 代码

1. public void sort(int[] a) {   
2.     int t;   
3.     for (int i = 0; i < a.length; i++) {   
4.         for (int j = i + 1; j < a.length; j++) {   
5.             if (a[i] > a[j]) {   
6.                 t = a[i];   
7.                 a[i] = a[j];   
8.                 a[j] = t;   
9.             }   
10.         }   
11.     }   
12. }  

 冒泡排序

java 代码

1. public void sort(int[] arr) {   
2.     boolean exchange; // 交换标志   
3.     int i, j;   
4.     int temp;   
5.     for (i = 1; i < arr.length; i++) {   
6.         exchange = false;   
7.         for (j = arr.length - 1; j >= i; j--) {   
8.             // 对当前无序区R[i..n]自下向上扫描   
9.             if (arr[j] < arr[j - 1]) {// 交换记录   
10.                 temp = arr[j]; // R[0]不是哨兵，仅做暂存单元   
11.                 arr[j] = arr[j - 1];   
12.                 arr[j - 1] = temp;   
13.                 exchange = true; // 发生了交换，故将交换标志置为真   
14.             }   
15.         }   
16.         if (!exchange) // 本趟排序未发生交换，提前终止算法   
17.             return;   
18.     }   
19. }  

 插入法：

java 代码

1. public void insertSort(int[] r) {   
2.     int c, i, j;   
3.     // 从第2个开始比较   
4.     for (i = 1; i < r.length; i++) {   
5.         // 用来存放比较值的空间   
6.         c = r[i];   
7.         // 前一个值   
8.         j = i - 1;   
9.         // 如果前一个值大于0并且大于比较的值   
10.         while (j >= 0 && r[j] > c) {   
11.             /*  
12.              * 这里值得注意：如果我们没有为待比较数值声明 存储空间，那个在做这一步时，会将待比较数值覆盖。  
13.              */  
14.             // 将后一个值变为前一个值   
15.             r[j + 1] = r[j];   
16.             // 向前移动继续比较   
17.             j--;   
18.         }   
19.         // 将当前值改为比较用的值   
20.         r[j + 1] = c;   
21.   
22.         // 打印每次排序后的顺序   
23.         for (int n = 0; n < r.length; n++) {   
24.             System.out.print(r[n] + ",");   
25.         }   
26.         System.out.print("\n");   
27.     }   
28. }  

 

选择法：该方法通过遍历集合记录最小（大）元素的位置，一次遍历完后，再进行交换位置操作，类似冒泡，但在比较过程中，不进行交换操作，只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后, 我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.

java 代码

1. public static void xuanze(int[] data) {   
2.      int temp;   
3.      for ( int i = 0; i < data.length; i++ ) {   
4.           int lowIndex = i;   
5.           for ( int j = data.length - 1; j > i; j-- ) {   
6.                if (data[j] 〉 data[lowIndex]) {   
7.                     lowIndex = j;   
8.                }   
9.           }   
10.           temp=data[i];   
11.           data[i]=data[lowIndex];   
12.           data[lowIndex]=temp;   
13.      }   
14. }  

Shell排序：
它是对插入排序的一种改进，是考虑将集合元素按照一定的基数划分成组去排序，让每一组在局部范围内先排成基本有序，最后在进行一次所有元素的插入排序。

java 代码

1. public void sort(int[] data) {   
2.       for( int i=data.length/2; i>2; i/=2 ) {   
3.             for( int j=0; j
4.                   insertSort(data,j,i);   
5.             }   
6.       }   
7.       insertSort(data,0,1);   
8. }   
9.   
10. private void insertSort(int[] data, int start, int inc) {   
11.       int temp;   
12.       for( int i=start+inc; i
13.             for( int j=i; ( j>=inc ) && ( data[j] < data[j-inc]) ; j-=inc ) {   
14.                   temp=data[j];   
15.                   data[j]=data[j-inc]   
16.                   data[j-inc]=temp;   
17.             }   
18.       }   
19. }  

参考：

http://student.zjzk.cn/course_ware/data_structure/web/main.htm 数据结构

http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.1.1.1.htm 排序