冒泡排序
思想：循環n次，交換左右兩側數據，外層每循環一次可以把無序中最大的（最小）的元素放到無序的最後面
時間複雜度：
平均：O(N^2)（一共循環：f(n) = (n-1)+(n-2)+...+2+1 = n*(n-1)/2 次）
O(f(n)) = n^2（只留f(n)的最高項，並且去掉最高項的係數）
最好：O(N)（優化冒泡排序：排序數列本身就有序的情況）
最壞：O(N^2)
空間複雜度：O(1)
空間複雜度(Space Complexity)是對一個算法在運行過程中臨時佔用存儲空間大小的量度
穩定性：穩定排序
八種排序的穩定性
不穩定：快速排序，選擇排序，堆排序，希爾排序（快選堆希）
穩定：插入排序，冒泡排序，歸併排序，基數排序（插冒歸基）
算法的穩定性判斷：排序前，2個相等的數在序列中的前後位置順序，與，排序後，它們兩個的前後位置順序相同
代碼實現：
// 左右兩側比較
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; ++i) {
for (int j = 0; j < array.length - i - 1; ++j) {
if (array[j] > array[j + 1]) {
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}
// 優化
public static void bubbleSort2(int[] array) {
for (int i = 0; i < array.length - 1; ++i) {
boolean flag = true;
for (int j = 0; j < array.length - i - 1; ++j) {
if (array[j] > array[j + 1]) {
flag = false;
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
if (flag) {
break;// 排序序列本身已有序
}
}
}
快速排序
思想：
1、找一個基準值（關鍵數）
方法1：排序序列中最左/右的數（一般用此方法）
方法2：隨機取值
方法3：三數取中法
2、讓整個數組中比基準值小的值放於基準值左側，反之放於基準值右側
方法1：左右下標法
方法2：挖坑法
方法3：前後下標法
3、將數組分成3部分：左、基準值、右
4、分而治之（子問題的思想）
時間複雜度：
平均：O(NlgN)
根據代碼我們知道，每一層的遞歸操作次數爲該次遞歸所傳入的元素個數，忽略每次減去的樞軸（1個元素並沒有給到下一層，但是每層這裏減掉一個常數對複雜度的分析影響不大，所以暫時忽略），即：
第1層是n次，
第2層有2次遞歸，每次n/2次，共n次操作，
第3層有4次遞歸，每次n/4次，共n次操作，
……
（最後一層）第k層有k次遞歸，每次n/2^k次，共n次操作
由於遞歸結束的條件是隻有一個元素，所以這裏的n/2^k=1 => k=logn
即遞歸樹的深度爲logn
時間複雜度=每層的操作次數*樹的深度=nlogn 即：O(nlgn);
最好：O(NlgN)
最壞：O(N^2)//排序序列是逆序的
空間複雜度：O(NlgN)；最壞時，O(N)
遞歸調用，爲它的下一個遞歸調用函數開闢出一塊新的空間，而每次的新的空間只需要一個temp存放基準元素即可。一共發生(logn(較好和一般情況下))，所以需要的空間是O(logn)，最壞的空間複雜度是（o(n)此時發生了n次調用）
穩定性：不穩定排序
代碼實現：
1）左右下標法
public static void quickSort(int[] array, int beg, int end) {
if(beg >= end) {
return;
}
//partSort()完成基準值的選擇以及數字交換一次的過程
int index = partSort(array, beg, end);
quickSort(array, beg, index - 1);
quickSort(array, index + 1, end);
}
//左右下標
private static int partSort(int[] array, int beg, int end) {
int left = beg;
int right = end;
int key = array[end];//基準值
while(left < right) {
while(left < right && array[left] <= key) {
++left;//保證循環完畢之後left指向一個大於key的值
}
while(left < right && array[right] >= key) {
--right;//保證循環完畢之後right指向一個小於key的值
}
if(left < right) {
swap(array, left, right);//交換：此時left與right未相遇
}
}
swap(array, left, end);//交換：此時left與right已相遇
return left;
}
private static void swap(int[] array, int num1, int num2) {
int tmp = array[num1];
array[num1] = array[num2];
array[num2] = tmp;
}
2）挖坑法：空出一個位置最後存放基準值
private static int partSort1(int[] array, int left, int right) {
int key = array[right];// 基準值
while (left < right) {
while (left < right && array[left] <= key) {
++left;// 保證循環完畢之後left指向一個大於key的值
}
array[right] = array[left];//坑位
while (left < right && array[right] >= key) {
--right;// 保證循環完畢之後right指向一個小於key的值
}
array[left] = array[right];//坑位
}
//left先走，所以最後一個坑位在right下標
array[right] = key;//找出key基準值適合的位置
return right;
}
3）前後下標法
private static int partSort2(int[] array, int left, int right) {
if(left < right) {
int key = array[right];// 基準值
int cur = left;
int pre = cur - 1;
while (cur < right) {
//當cur小於key時，pre就一直跟在cur之後，所以第二個條件不會成立
while (array[cur] < key && ++pre != cur) {
swap(array, cur, pre);//當cur大於key值時，就不會執行++pre，就會拉開pre的距離
//所以在pre和cur之間的值都是大於pre的值
//而進入該循環時，條件成立，將小於key的值與pre~cur之間的值交換
}
++cur;
}
swap(array, ++pre, right);
return pre;
}
return -1;
}