今天開始復習一下排序，其實這個最近都有再撿起來練，畢竟太久遠拿起來還挺不容易的。
簡單說一下——自己復習排序的時候理解是這樣的：基本的排序分為三類：交換排序、選擇排序、插入排序。用一張圖表示一下：
不得不說，我畫的圖簡直太丑了......
將就看一下吧，大概是這樣的。前面的話有點多了，直接進入今天的正題——交換排序。
冒泡排序：BubbleSort
冒泡排序應該是最簡單的了吧？額，至少我個人覺得應該是最好理解的一種排序。
百度百科的原理：
1.比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
3.針對所有的元素重復以上的步驟，除了最后一個。
4.持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
說起原理來感覺好難懂是吧？？？
其實可以簡單去思考：為啥叫冒泡排序呢？
不知道有沒有注意過水里的氣泡，大的氣泡會浮到上面去。冒泡排序也是：每一輪的排序,在這一輪中參與比較的元素中最大的數將會浮到最后。
時間復雜度之類的分析，我寫在了備注中~~~
So,直接上代碼：
請注意第二層for循環，循環次數會越來越小，簡單思考一下就會發現：畢竟每輪過后相對來說最大的數都會排到應該在的地方去，所以如果再多比較那幾次也沒啥意義~
/**
* Created by AceCream on 2017/3/19.
* 冒泡排序BubbleSort（屬于交換排序）
* 時間復雜度： 平均：O(n^2) 最佳：O(n) 最壞：O(n^2)
* 空間復雜度： O(1)
* 穩定性： 穩定
*/
public class BubbleSort {
public static void bubbleSort(int[] values){
for (int i=0;i<values.length;i++){
for (int j=i;j<values.length;j++){
if (values[i]>values[j]){
int temp = values[i];
values[i] = values[j];
values[j] = temp;
}
}
}
}
public static void main(String[] args) {
int value[] = {1,7,5,8,3};
bubbleSort(value);
for (int result : value) {
System.out.print(result+" ");
}
}
}
快速排序：Quicksort
為啥叫快速排序？因為他比別的排序快啊！當然這是一般情況下，也就是平均情況下，快速排序的時間復雜度是O(nlogn)，這速度真的不要太快！
！！！但是！！！
“快速排序是最快的排序”，這句話是正確的嗎？？？
答案是：“不準確！”
因為按照平均速度來說，它確實很快，但是如果“樞紐元”為最大或者最小數字，那這個時候簡直就是災難！對！災難！它就直接成為了——冒泡排序（Ps：冒泡：“靠！這個鍋，我不背！”）
具體這個“樞紐元”是啥？還是從快速排序的原理說起來：
快排原理
原理：
- 確定一個基準值
- 一次循環：從后往前比較，用基準值和最后一個值比較，
- 如果比基準值小的交換位置，如果沒有繼續比較下一個，
- 直到找到第一個比基準值小的值才交換。
- 找到這個值之后，又從前往后開始比較，如果有比基準值大的，交換位置，
- 如果沒有繼續比較下一個，直到找到第一個比基準值大的值才交換。
- 直到從前往后的比較索引>從后往前比較的索引，結束第一次循環。
- 此時，對于基準值來說，左右兩邊就是有序的了。
- 接著分別比較左右兩邊的序列，重復上述的循環。
行了，看了原理，我相信基本上都懵逼了，我當初也是被快排折磨是不行，找了大量的文檔，沒看懂。后來自己每一步都在紙上寫一遍，終于發現了其精髓所在！
簡單來說，快速排序其實是冒泡排序的加強版！從成熟體化身為完全體！至于究極體，還得在其基礎上繼續優化~~
我們第一次循環中，確定的這個“基準值”，就是上文所述的“樞紐元”。
借用一下百科的圖片：
這個圖挺好，但是“初始”和“一次劃分”中間省略了很多步，我來補充一下：想象一下挖坑~
1.首先把第一個值，也就是49作為key值，取出來存坑里
2.從右邊開始向左邊，依次和key值比較，一旦發現比它小的了也就是27，就把27挖出來，填在它曾經的坑里(第一個位置)。這時候變成了這個樣子：
27，38，65，97，76，13，27，49
3.那么這時候，出現了倆27，這第二個27，人已經走了，但是它的坑還在，很尷尬，咋辦？我們繼續走下一步，從左邊開始比較(注意！就不要從第一個開始了，已經比較完了，就從38開始吧)，比較誰？還是依次與key(49)比較，直到發現比key大的數，也就是65，這時候就把65，放到剛剛那個尷尬的坑里，把“坑里的值”更新掉~于是變成了這樣：
27，38，65，97，76，13，65，49
然后把最開始挖出來的那個49填坑里
27，38，49，97，76，13，65，49
但是這樣就結束第一此劃分了嗎？并沒有，因為從start開始的left值和end開始的right值，還沒有碰到一起(left<right),所以繼續走，重復剛才的動作，直到他們相遇，這個時候：49左邊的數都小于49，右邊的數都大于或等于49。也就完成了第一次劃分。
這之后我們看一下上面的圖，以49為中心，分成了兩個部分，這里就體現了“分治”的思想。將一個問題，分解成兩個小的部分，分別做相同的操作。將兩個部分做同樣的操作，你想到了什么方式？對！遞歸！快速排序，體現了算法的兩大思想：遞歸和分治。所以快速排序才這么重要。
這里多說一句，前面說過如果這個"樞紐元"選的不好，那就很尷尬了，比如說，這組數，我第一個值如果不是49而是13呢？那第一次劃分后，13放在了最左邊，我們再看第二個值，如果第二個值是27呢？以此類推，如果我的這串數字剛開始就比較有序，那么快排反而成為了冒泡啊！時間復雜度變為了N(n^2)，所以說，快速排序并不穩定。
但是！我們不能因為這個就否定它，畢竟在大量的測試中，快速排序的速度是要優與堆排序和shell排序的。
是不是聽起來很暈。自己動手（請在紙上）寫一遍流程其實就懂得了~~
接下來，直接手敲代碼：
/**
* Created by AceCream on 2017/3/19.
* 快速排序QuickSort （屬于交換排序）
* 原理：
* 一次循環：從后往前比較，用基準值和最后一個值比較，
* 如果比基準值小的交換位置，如果沒有繼續比較下一個，
* 直到找到第一個比基準值小的值才交換。
* 找到這個值之后，又從前往后開始比較，如果有比基準值大的，交換位置，
* 如果沒有繼續比較下一個，直到找到第一個比基準值大的值才交換。
* 直到從前往后的比較索引>從后往前比較的索引，結束第一次循環。
* 此時，對于基準值來說，左右兩邊就是有序的了。
* 接著分別比較左右兩邊的序列，重復上述的循環。
*
* 時間復雜度： 平均：O(nlog2n) 最佳：O(nlog2n) 最壞：O(n^2)
* 空間復雜度： O(1)
* 穩定性： 不穩定
*
*/
public class QuickSort {
private static void quickSort(int[] value, int start, int end) {
int left = start;
int right = end;
int key = value[start];
while (left<right){
while (left<right&&value[right]>=key){
right--;
}
if (left<right){
value[left] = value[right];
left++;
}
while (left<right&&value[left]<key){
left++;
}
if (left<right){
value[right] = value[left];
right--;
}
value[left] = key;
if (left>start) quickSort(value,start,left-1);
if (right<end) quickSort(value,right+1,end);
}
}
public static void main(String[] args) {
int[] value = {49,38,65,97,76,13,27,49};
int start = 0;
int end = value.length-1;
quickSort(value,start,end);
//打印出來
for (int result : value) {
System.out.print(result+" ");
}
}
}
