Java 排序

public static void main(String[] args) {
  String[] sum = { "ac", "ca", "bk", "w", "d1" };
  Arrays.sort(sum);
  for (int i = 0; i < sum.length; i++) {
   System.out.print(sum[i] + "  ");
  }
}


java 排序 调换位置的静态方法：
­
public class SortUtil {         public static void swap(int a[], int i, int j) {             int tmp = a[i];             a[i] = a[j];             a[j] = tmp;         }    }    冒泡排序，快速排序，选择排序，插入排序等。
java 代码
­
public void sort(int[] a) {        int t;        for (int i = 0; i < a.length; i++) {            for (int j = i + 1; j < a.length; j++) {                if (a[i] > a[j]) {                    t = a[i];                    a[i] = a[j];                    a[j] = t;                }            }        }    }    冒泡排序
java 代码
­
public void sort(int[] arr) {        boolean exchange; // 交换标志        int i, j;        int temp;        for (i = 1; i < arr.length; i++) {            exchange = false;            for (j = arr.length - 1; j >= i; j--) {                // 对当前无序区R[i..n]自下向上扫描                if (arr[j] < arr[j - 1]) {// 交换记录                    temp = arr[j]; // R[0]不是哨兵，仅做暂存单元                    arr[j] = arr[j - 1];                    arr[j - 1] = temp;                    exchange = true; // 发生了交换，故将交换标志置为真                }            }            if (!exchange) // 本趟排序未发生交换，提前终止算法                return;        }    }   插入法：
java 代码
­
public void insertSort(int[] r) {        int c, i, j;        // 从第2个开始比较        for (i = 1; i < r.length; i++) {            // 用来存放比较值的空间            c = r[i];            // 前一个值            j = i - 1;            // 如果前一个值大于0并且大于比较的值            while (j >= 0 && r[j] > c) {                /*                * 这里值得注意：如果我们没有为待比较数值声明 存储空间，那个在做这一步时，会将待比较数值覆盖。                */               // 将后一个值变为前一个值                r[j + 1] = r[j];                // 向前移动继续比较                j--;            }            // 将当前值改为比较用的值            r[j + 1] = c;               // 打印每次排序后的顺序            for (int n = 0; n < r.length; n++) {                System.out.print(r[n] + ",");            }            System.out.print("\n");        }    }    
选择法：该方法通过遍历集合记录最小（大）元素的位置，一次遍历完后，再进行交换位置操作，类似冒泡，但在比较过程中，不进行交换操作，只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后, 我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.
java 代码
­
public static void xuanze(int[] data) {         int temp;         for ( int i = 0; i < data.length; i++ ) {              int lowIndex = i;              for ( int j = data.length - 1; j > i; j-- ) {                   if (data[j] 〉 data[lowIndex]) {                        lowIndex = j;                   }              }              temp=data[i];              data[i]=data[lowIndex];              data[lowIndex]=temp;         }    }   Shell排序：
它是对插入排序的一种改进，是考虑将集合元素按照一定的基数划分成组去排序，让每一组在局部范围内先排成基本有序，最后在进行一次所有元素的插入排序。
java 代码
­
public void sort(int[] data) {          for( int i=data.length/2; i>2; i/=2 ) {                for( int j=0; j                   insertSort(data,j,i);                }          }          insertSort(data,0,1);    }       private void insertSort(int[] data, int start, int inc) {          int temp;          for( int i=start+inc; i             for( int j=i; ( j>=inc ) && ( data[j] < data[j-inc]) ; j-=inc ) {                      temp=data[j];                      data[j]=data[j-inc]                      data[j-inc]=temp;                }          }    }