在看<<大話數據結構>>這本書中關于排序這一章的時候，我試著用javascript語言來重寫里面幾個經典的排序方法，包括冒泡排序、快速排序、選擇排序、插入排序還有希爾排序。

一、冒泡排序

冒泡排序算是排序中最常見的，冒泡排序分為兩個，一種是從小到大，一種是從打到小，具體是實現步驟就是：從最開始的位置或者最后的位置反方向對比，如果比它大/小，就交換然后繼續走，第一遍走完，最后一個位置是最大值或者最小值，時間復雜度為O（n^2），是穩定的排序，用JS實現的代碼如下：

//冒泡排序
        function exchange(array,i,j){
            var t = array[i];
            array[i] =  array[j];
            array[j] = t;
        }
        function bubbleSort(arr){
            for(var i=0; i<arr.length; i++){
                for(var j=0;j<arr.length-i;j++){
                    if(arr[j] > arr[j+1]){
                          exchange(arr,j,j+1);
                    }
                }
                console.log(arr.toString());
            }
            return arr;
        }
        var nums = [2,3,4,3,1,5,7,122,341,-1];
        console.log(bubbleSort(nums));

在瀏覽器上顯示的步驟為：

冒泡.PNG

二、快速排序

快速排序就是一開始找一中點，然后把比它小的放左邊，比它大的放右邊，然后重新對中介兩邊的數組，各自重新執行快速排序，如此循環，代碼如下：

//快速排序
        function quickSort(arr){
            if(arr.length <= 1){
                return arr;
            }
            console.log("原數組是:" + arr);
            var pivotIndex = Math.floor(arr.length/2);
            var pivot = arr.splice(pivotIndex,1)[0];
            console.log("將中介提取出來后數組是:"+arr);
            var left = [];
            var right = [];
            for(var i=0;i<arr.length;i++){
                console.log("此刻中介是:"+pivot+"當前元素是:"+arr[i]);
                if(arr[i] > pivot){
                    right.push(arr[i]);
                    console.log("移動元素:"+arr[i]+"到右邊");
                } else{
                    left.push(arr[i]);
                    console.log("移動元素:"+arr[i]+"到左邊");
                }
            }
            return quickSort(left).concat([pivot],quickSort(right));
        }
        console.log(quickSort(nums));

快速排序的時間復雜度為O(nlogn),屬于不穩定排序。

三、選擇排序

選擇排序就是選擇數組中第一個元素，將它和其他元素進行對比，跟最小的交換，然后從第二個元素開始，繼續跟后面的比，跟剩余里面最小的交換，直到循環結束，代碼如下：

//選擇排序
        function selectSort(arr){
            var min = 0;
            for(var i=0;i<arr.length;i++){
                 min = i;
                 for(var j=i+1;j<arr.length;j++){
                    if(arr[j]<arr[min]){
                        min = j;
                    }
                 }
                 if(i!=min){
                    exchange(arr,i,min);
                 }
            }
            return arr;
        }
        console.log(selectSort(nums));

選擇排序的時間復雜度為O(n^2)。

四、插入排序

插入排序就是將數組分成“已排序”和“未排序”兩部分，剛開始，“已排序”的部分只有一個元素，就是第一個元素，然后依次將后面”未排序“中的元素，部分插入到“已排序”中，從而“已排序”部分增加一個元素，“未排序”部分減少一個元素，直到循環結束，代碼如下：

//直接插入排序
        function insertSort(arr){
            console.log("原數組:"+arr);
            for(var i=0;i<=arr.length;i++){
                for(var j=i;j>0 && arr[j]<arr[j-1];j--){
                    exchange(arr,j,j-1);
                    console.log("此時數組:"+arr);
                }
            }
            return arr;
        }
        console.log(insertSort(nums));

插入排序的時間復雜度為O(n^2),是穩定的排序。

五、希爾排序

希爾排序的實質是分組插入排序，該方法又稱縮小增量排序。該方法的基本思想是：先將整個待排元素序列分割為若干個子序列（由相隔某個‘增量’的元素組成的）分別進行直接插入排序，然后依次縮減增量再進行排序，帶這個序列中的元素基本有序（增量足夠小）時，再對全體元素進行一次直接插入排序。因為直接插入排序在元素基本有序的情況下（接近最好情況）效率是很高的，因此希爾排序在時間效率上有較大的提高，代碼如下：

//希爾排序
        function shellSort(arr){
            console.log("原數組:"+arr);
            var increment = arr.length;
            var i = 0;
            var temp = 0;
            do{
               increment = Math.floor(increment / 3) + 1;
               for(i = increment; i < arr.length; i++){
                if(arr[i] < arr[i-increment]){
                    temp = arr[i];
                    for(var j = i-increment; j>=0 && temp < arr[j]; j-=increment){
                        arr[j + increment] = arr[j];
                    }
                    arr[j + increment] = temp;
                }
               }
            }while(increment > 1);
            return arr;
        }
        console.log(shellSort(nums));