JS家的排序算法

時間 2019-11-20

原文原文鏈接

因爲瀏覽器的原生支持(無需安裝任何插件),用JS來學習數據結構和算法也許比c更加便捷些。由於只需一個瀏覽器就能啪啪啪的調試了。好比下圖我學習歸併排序算法時，只看代碼感受怎麼都理解不了，可是結合chrome自帶的斷點調試功能，我便很快理解了其中的思想。html

冒泡排序

冒泡排序比較任何兩個相鄰的項,若是第一個比第二個大,則交換它們。元素項向上移動至正確的順序,就好像氣泡升至表面同樣,冒泡排序所以得名。 web

冒泡排序動圖演示：算法

冒泡排序JavaScript代碼實現：chrome

    /*冒泡排序*/
    this.bubbleSort = function() {
        var length = array.length;
        for (var i = 0; i < length; i ++){ 
            for (var j = 0; j < length - 1; j++){ 
                if (array[j] > array[j + 1]) {
                    swap(j, j + 1);
                }
            }
        }
    };

可是舉個例子好比把數組[5,4,3,2,1]進行冒泡排序，它的工做過程以下:數組

當算法執行外循環的第二輪的時候,數字4和5已是正確排序的了。儘管如此,在後續比較中,它們還一直在進行着比較,即便這是沒必要要的。瀏覽器

改進後的冒泡排序:數據結構

//改進的冒泡排序
    this.bubbleSort = function() {
        var length = array.length;
        for (var i = 0; i < length; i++) {
            for (var j = 0; j < length - (i + 1); j++) { //從內循環減去外循環中已跑過的輪數，就能夠避免內循環中全部沒必要要的比較 
                if (array[j] > array[j + 1]) {
                    swap(j, j + 1);
                }
            }
        }
    };

/*可複製到瀏覽器中測試*/
function ArrayList() {

    var array = [5, 4, 3, 2, 1];

    this.insert = function(item) {
        array.push(item);
    };

    this.toString = function() {
        return array.join();
    };

    // /*冒泡排序*/
    // this.bubbleSort = function() {
    //     var length = array.length;
    //     for (var i = 0; i < length; i ++){       //次數
    //         for (var j = 0; j < length - 1; j++){ 
    //             if (array[j] > array[j + 1]) {
    //                 swap(j, j + 1);
    //             }
    //         }
    //     }
    // };

    //改進的冒泡排序
    this.bubbleSort = function() {
        var length = array.length;
        for (var i = 0; i < length; i++) { //次數
            for (var j = 0; j < length - (i + 1); j++) { //從內循環減去外循環中已跑過的輪數 
                if (array[j] > array[j + 1]) {
                    swap(j, j + 1);
                }
            }
        }
    };

    /* 選擇排序 */
    // this.selectionSort = function() {
    //     var length = array.length,
    //         indexMin;
    //     for (var i = 0; i < length - 1; i++) {
    //         indexMin = i;
    //         for (var j = i; j < length; j++) {
    //             if (array[indexMin] > array[j]) {
    //                 indexMin = j;
    //             }
    //         }
    //         if (i !== indexMin) {
    //             swap(i, indexMin);
    //         }
    //     }
    // }

    var swap = function(index1, index2) {
        var aux = array[index1];
        array[index1] = array[index2];
        array[index2] = aux;
    };
}

var array = new ArrayList();
console.log(array.toString());
array.bubbleSort();
//array.selectionSort();
console.log(array.toString());

完整代碼

選擇排序

選擇排序思路就是找到數據結構中的最小值並 2 將其放置在第一位,接着找到第二小的值並將其放在第二位,以此類推。數據結構和算法

選擇排序JavaScript代碼實現ide

this.selectionSort = function() {
        var length = array.length,
            indexMin;
        for (var i = 0; i < length - 1; i++) {
            indexMin = i;
            for (var j = i; j < length; j++) {
                if (array[indexMin] > array[j]) {
                    indexMin = j;
                }
            }
            if (i !== indexMin) {
                swap(i, indexMin);
            }
        }
    }

/* 複製到chrome控制檯便可測試 */
function ArrayList() {

    var array = [5, 4, 3, 2, 1];

    this.insert = function(item) {
        array.push(item);
    };

    this.toString = function() {
        return array.join();
    };

    /*冒泡排序*/
    // this.bubbleSort = function() {
    //     var length = array.length;
    //     for (var i = 0; i < length; i ++){       //次數
    //         for (var j = 0; j < length - 1; j++){ 
    //             if (array[j] > array[j + 1]) {
    //                 swap(j, j + 1);
    //             }
    //         }
    //     }
    // };

    //改進的冒泡排序
    // this.bubbleSort = function() {
    //     var length = array.length;
    //     for (var i = 0; i < length; i++) { //次數
    //         for (var j = 0; j < length - (i + 1); j++) { //從內循環減去外循環中已跑過的輪數 
    //             if (array[j] > array[j + 1]) {
    //                 swap(j, j + 1);
    //             }
    //         }
    //     }
    // };

    /* 選擇排序 */
    this.selectionSort = function() {
        var length = array.length,
            indexMin;
        for (var i = 0; i < length - 1; i++) {
            indexMin = i;
            for (var j = i; j < length; j++) {
                if (array[indexMin] > array[j]) {
                    indexMin = j;
                }
            }
            if (i !== indexMin) {
                swap(i, indexMin);
            }
        }
    }

    var swap = function(index1, index2) {
        var aux = array[index1];
        array[index1] = array[index2];
        array[index2] = aux;
    };
}

var array = new ArrayList();
console.log(array.toString());
// array.bubbleSort();
array.selectionSort();
console.log(array.toString());

完整測試代碼

插入排序

插入排序是每次排一個數組項,以此方式構建最後的排序數組。假定第一項已經排序了,接着, 它和第二項進行比較,第二項是應該待在原位仍是插到第一項以前呢?這樣,頭兩項就已正確排序,接着和第三項比較(它是該插入到第1、第二仍是第三的位置呢?),以此類推。性能

插入排序動圖演示：

插入排序JavaScript代碼實現：

//插入排序
    this.insertionSort = function() {
        var length = array.length,
            j, temp;
        for (var i = 1; i < length; i++) {
            j = i;
            temp = array[i];
            while (j > 0 && array[j - 1] > temp) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = temp;
        }
    };

function ArrayList() {

    var array = [3, 5, 1, 4, 2];

    this.insert = function(item) {
        array.push(item);
    };

    this.toString = function() {
        return array.join();
    };

    //插入排序
    this.insertionSort = function() {
        var length = array.length,
            j, temp;
        for (var i = 1; i < length; i++) {
            j = i;
            temp = array[i];
            while (j > 0 && array[j - 1] > temp) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = temp;
        }
    };

}

var array = new ArrayList();
console.log(array.toString());
array.insertionSort();
console.log(array.toString());

完整測試代碼

歸併排序

歸併排序是第一個能夠被實際使用的排序算法。前三個排序算法性能很差,但歸併排序性能不錯,其複雜度爲O(nlogn)。其中火狐，sarify的sort()方法就是基於歸併算法實現的。

小建議：學習歸併排序時能夠如我最開始所說的，在chrome裏打斷點一步步看輸出，一遍下來就基本上能理解其本質了。

歸併排序JavaScript代碼實現：

完整測試代碼

快速排序

快速排序也許是最經常使用的排序算法了。它的複雜度爲O(nlogn),且它的性能一般比其餘的復雜度爲O(nlogn)的排序算法要好。和歸併排序同樣,快速排序也使用分治的方法,將原始數組分爲較小的數組(但它沒有像歸併排序那樣將它們分割開)。 chrome的sort()方法是基於快速排序實現的。

快速排序動圖演示：

講下快速排序的思路

在數據集之中，選擇一個元素做爲"基準"（pivot）。
全部小於"基準"的元素，都移到"基準"的左邊；全部大於"基準"的元素，都移到"基準"的右邊。
對"基準"左邊和右邊的兩個子集，不斷重複第一步和第二步，直到全部子集只剩下一個元素爲止。

想詳細瞭解的話能夠閱讀下這篇文章

快速排序JavaScript代碼實現：

function ArrayList() {
    var array = [3, 5, 1, 6, 4, 7, 2];

    this.toString = function() {
        return array.join();
    };

    this.quickSort = function() {
        quick(array, 0, array.length - 1);
    };
}

var quick = function(array, left, right) {
    var index;

    if (array.length > 1) {

        index = partition(array, left, right);

        if (left < index - 1) {
            quick(array, left, index - 1);
        }

        if (index < right) {
            quick(array, index, right);
        }
    }
};


//劃分過程
var partition = function(array, left, right) {
    var pivot = array[Math.floor((right + left) / 2)],
        i = left,
        j = right;

    while (i <= j) {
        while (array[i] < pivot) {
            i++;
        }
        while (array[j] > pivot) {
            j--;
        }

        if (i <= j) {
            swapQuickStort(array, i, j);
            i++;
            j--;
        }
    }
    return i;
};

var swapQuickStort = function(array, index1, index2) {
    var aux = array[index1];
    array[index1] = array[index2];
    array[index2] = aux;
};

var array = new ArrayList();
console.log(array.toString());
array.quickSort();
console.log(array.toString());