一、冒泡排序
时间复杂度：O(n^2)
公认最慢的排序，每次把最大/最小的放一边，原理：
[57,68,59,52]
[57,68,59,52]
[57,59,68,52]
[57,59,52,68]
每次比较把相对大的数往后移，最后放到最后一位的就是整个数组中最大的数了，然后对n-1个数继续排序。
public class BubbleSort {
public static <T extends Comparable> void sort(T[] src){
T tmp;
int len = src.length;
for(int i=0;i<len-1;i++){ // 注意是小于len-1，即遍历到倒数第二个元素
for(int j=0;j<len-1-i;j++){
if(src[j].compareTo(src[j+1])>0){
tmp = src[j];
src[j] = src[j+1];
src[j+1] = tmp;
}
}
}
}
}
二、快速排序
时间复杂度：O(nlogn) 最坏情况：O(n^2)
空间复杂度：O(nlogn)
不稳定。
原理：选定基准值，把比它大的放右边，比它小的放左边，这样就分成了两块，对这两块重复以上步骤。
实际操作：
[15,11,18,13,19,17,12,16,14] 移动high指针，low=0,high=8,pivot=15[位置0]，第一次对比，14比基准值15小，src[low=0] = src[high8]
[14,11,18,13,19,17,12,16,14] 移动low指针，low依次=0,1,2，high=8，14和11都比15大，18比15大，src[high=8] = src[low=2]
[14,11,18,13,19,17,12,16,18] 移动high指针，low=2,high依次=8,7,6，到12比15小，src[low=2] = src[high=6]
[14,11,12,13,19,17,12,16,18] 移动low指针，low依次=2,3,4，high=6，19比15大，src[high=6] = src[low=4]
[14,11,12,13,19,17,19,16,18] 移动high指针，low=4，high依次=6,5,4，19和17都不小于15，到high=4，!low<high，此时的low/high就是基准值位置
[14,11,12,13,19,17,19,16,18] 现在low=4，high=4，low/high[4] = pivot，19位置值等于基准值
[14,11,12,13],,[17,19,16,18] 分成两块了，再对这两块重复以上步骤，直到分出的值不多于一个。
public class QuickSort {
public static void sort(int[] src){
quickSort(src,0,src.length-1);
}
private static void quickSort(int[] src,int low,int high){
if(low<high){
int mid = partition(src,low,high); // 获得中间值的位置
quickSort(src,low,mid-1); // 对左部分快排
quickSort(src,mid+1,high); // 对右部分快排
}
}
private static int partition(int[] src,int low,int high){
int tmp = src[low]; // 记录基准值
while(low<high){ // 相等时，说明剩一个值，这就是基准值的最终位置
while(low<high&&src[high]>=tmp){
high--; // 从high开始，至有一个比基准值小的值时，high指针不动，下面的while从low开始找
}
src[low] = src[high]; // 交换值
while(low<high&&src[low]<=tmp){
low++;
}
src[high] = src[low];
}
src[low] = tmp;
return low;
}
}
-2014年04月28日--------------------更新了BubbleSort的代码