✊不积跬步，无以至千里；不积小流，无以成江海。

一、简单排序

1、冒泡排序

  1. /**
  2.  ** 比较相邻的元素；若前一个大于后一个，则交换元素位置 
  3.  ** 外循环控制冒泡次数，内循环控制每次冒泡的元素比较个数
  4.  ** 时间复杂度O(n^2)
  5.  **/
  6. public class Bubble{
  8.     // 对数组内的元素进行排序
  9.     public static void sort(Comparable[] a){
  10.         for(int i=a.length-1; i>0; i--){
  11.             for(int j=0; j<i; j++){
  12.                 if(greater(a[j], a[j+1])){
  13.                     exch(a, j, j+1);
  14.                 }
  15.             }
  16.         }
  17.     }
  19.     // 判断v是否大于w
  20.     public static boolean greater(Comparable v, Comparable w){
  21.         return v.compareTo(w) > 0;
  22.     }
  24.     // 交换a数组中索引i和索引j处的值
  25.     public static void exch(Comparable[] a, int i, int j){
  26.         Comparable temp;
  27.         temp = a[i];
  28.         a[i] = a[j];
  29.         a[j] = temp;
  30.     }
  32. }

2、选择排序

  1. /**
  2.  ** 假定第一个索引处的元素为最小值，然后依次和其他索引处的值进行比较，若当前索引处的值大于
  3.  ** 后面的索引处的值，则重新赋最小索引，并交换该两个元素的位置
  4.  ** 外循环控制选择次数，内循环控制每次选择的元素比较个数
  5.  ** 时间复杂度O(n^2)
  6.  **/
  7. public class Selection {
  9.     // 依次比较较小值的索引值，若存在则交换位置
  10.     public static void sort(Comparable[] a){
  11.         for (int i=0; i<a.length-1; i++){
  12.             int minIndex = i;
  13.             // 找到最小元素的索引值
  14.             for (int j=i+1; j< a.length; j++){
  15.                 if (greater(a[minIndex],a[j])){
  16.                     minIndex = j;
  17.                 }
  18.             }
  19.             // 交换最小元素的位置
  20.             exch(a,i,minIndex);
  21.         }
  22.     }
  24.     public static boolean greater(Comparable v, Comparable w){
  25.         return v.compareTo(w) > 0;
  26.     }
  28.     public static void exch(Comparable[] a, int i, int j){
  29.         Comparable temp;
  30.         temp = a[i];
  31.         a[i] = a[j];
  32.         a[j] = temp;
  33.     }
  34. }

3、插入排序