javascript數據結構與算法--高級排序算法

javascript數據結構與算法--高級排序算法

     高級排序算法是處理大型數據集的最高效排序算法，它是處理的數據集能夠達到上百萬個元素，而不單單是幾百個或者幾千個。如今咱們來學習下2種高級排序算法---- 希爾排序和快速排序。

一：希爾排序；

希爾排序的核心理念是：首先比較距離較遠的元素，而非相鄰的元素。

基本原理：經過定義一個間隔序列來表示在排序過程當中進行比較的元素之間有多遠的間隔。

下面咱們來看看數組[0,9,1,8,7,6,2,3,5,4] 來使用希爾排序的原理；以下圖：

 

代碼分析以下：

1. 執行 "間隔序列=3的步驟"

    A. 那麼第一次執行 "間隔序列=3" 的步驟，那麼找到位置間隔3的元素爲 0 ,  8  , 2  , 4

        因此這四個數字當中0最小，因此位置不動，仍是第一個位置，8是最大的 因此位置就移動到以前的4的位置上，4移動到8的位置上，可是2和4比較 2小          於4的 因此2和4位置繼續調換。因此如今的順序爲0 , 2 , 4  , 8，如上圖(間隔序列=3)

   B. 如今第二次執行 "間隔序列=3" 的步驟，找到元素爲 9 , 7 , 3 分析仍是和上面的同樣 3是最小的，因此移動到原先9的位置上，9就移到到3的位置上，   由     於7小於9 因此不須要移動，因此如今的順序爲 3 , 7 , 9 如上圖(間隔序列=3)

  C. 如今第三次執行 "間隔序列=3"的步驟，找到元素 1 , 6 , 5 ,因爲1是最小的 因此不須要移動，6大於5，因此2者要調換位置 因此順序爲 1 , 5  , 6

      執行完上面的步驟後，正確的順序爲 [0,3,1,2,7,5,4,9,6,8]

2. 執行 "間隔序列=2"的步驟

   A. 第一次查找 找到元素 0,1,7,4,6,因此原理仍是和上面同樣，0和1不須要移動 7和4及6調換位置，所以如今的順序變爲 0,1,4,6,7

   B. 第二次查找 找到元素 3,2,5,9,8 ，因此順序變爲 2,3,5,8,9

 執行完上面的步驟後，正確的順序爲 [0,2,1,3,4,5,6,8,7,9] 如上圖(間隔序列=2)

3. 執行 "間隔序列=1"的步驟；

     數組的順序就變爲 [0,1,2,3,4,5,6,7,8,9].如上圖(間隔序列=1)

JS代碼以下：

function CArray(numElements,gaps) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.gaps = gaps;
    this.insert = insert;
    this.toString = toString;
    this.clear = clear;
    this.shellSort = shellSort;
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }            
}
function clear() {
    for(var i = 0; i < this.dataStore.length; i++) {
        this.dataStore[i] = 0;
    }
}
function insert(element) {
    this.dataStore[this.pos++] = element;
}
function toString() {
    var restr = "";
    for(var i = 0; i < this.dataStore.length; i++) {
        restr += this.dataStore[i] + " ";
        if(i > 0 && i % 10 == 0) {
            restr+= "\n";
        }
    }
    return restr;
}
        
function shellSort() {
    for(var g = 0; g < this.gaps.length; ++g) {
        for(var i = this.gaps[g]; i < this.dataStore.length; ++i) {
            var temp = this.dataStore[i];
            for(var j = i; j >= this.gaps[g] && this.dataStore[j - this.gaps[g]] > temp; j -= this.gaps[g]) {
                this.dataStore[j] = this.dataStore[j - this.gaps[g]];
            }
            this.dataStore[j] = temp;
        }
    }
}
// 希爾排序測試代碼
var numElements = [0,9,1,8,7,6,2,3,5,4];
var gaps = [3,2,1];
var myNums = new CArray(numElements,gaps);
myNums.shellSort();
console.log(myNums.toString());

二：快速排序

     快速排序是處理大數據集最快的排序算法之一。它是一種分而治之的算法，經過遞歸的方式將數據依次分解爲包含較小元素和較大的元素的不一樣子序列。該算法不斷重複這個步驟直到全部數據都是有序的。

這個算法首先要在列表中選擇一個元素來做爲基準值，數據排序圍繞基準值進行，將列表中小於基準值的元素移動到數組的左邊，將大於基準值的元素移動到數組的右邊，以下圖所示：

 

基本原理是：

1. 選擇一個基準元素，將列表分割成2個子序列。基準元素的選擇能夠有3種方式，能夠選擇第一個元素做爲基準元素，也能夠把中間的值做爲基準元素，還能夠把最後一個元素做爲基準的元素。
2. 對列表從新排序，將全部小於基準值的元素放在基準值的前面，全部大於基準值的元素放在基準值的後面。
3. 分別對較小元素的子序列和較大元素的子序列的重複步驟1和2.

下面是JS的代碼以下：

// 快速排序
function qSort(list) {
    if(list.length == 0) {
        return [];
    }
    // 存儲小於基準值的值
    var left = [];
    // 存儲大於基準值的值
    var right = [];
    var pivot = list[0];
    for(var i = 1; i < list.length; i++) {
        if(list[i] < pivot) {
            left.push(list[i]);
        }else {
            right.push(list[i])
        }
    }
    return qSort(left).concat(pivot,qSort(right));
}
// 快速排序測試代碼
var numElements = [44,75,23,43,55,12,64,77,33];
var list = qSort(numElements);
console.log(list);  // [12, 23, 33, 43, 44, 55, 64, 75, 77]