排序演算法

氣泡排序

依次比較相鄰的兩個數，將小數放在前面，大數放在後面。

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        //相鄰元素兩兩對比
            								//每進行一次for都能選出最大的值插在後面
                var temp = arr[j+1];        //元素交換
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}
 

選擇排序

每一次從待排序的資料元素中選出最小（或最大）的一個元素，存放在序列的起始位置

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     //尋找最小的數
                minIndex = j;                 //將最小數的索引儲存
            }
        }
        temp = arr[i];//將最小數與原索引數進行交換，確保前i個數已經進行排序
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}
 

插入排序

打撲克排序

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {//初始時，手裡只有一張牌
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {//遇到比它大的牌就向前比較
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;//插到比它小的牌後面
    }
    return arr;
}
 

歸併排序

歸併排序的實現由兩種方法：
自上而下的遞迴（所有遞迴的方法都可以用迭代重寫，所以就有了第2種方法）
自下而上的迭代

歸併排序是一種分而治之演算法。其思想是將原始陣列切分成較小的陣列，直到每個小陣列只有一個位置，接著將小陣列歸併成較大的陣列，直到最後只有一個排序完畢的大陣列。

function mergeSort(arr) {  //採用自上而下的遞迴方法
    var len = arr.length;
    if(len < 2) {
        return arr;
    }
    var middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right)
{
    var result = [];

    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }

    while (left.length)
        result.push(left.shift());

    while (right.length)
        result.push(right.shift());

    return result;
}

快速排序

又是一種分而治之思想在排序演算法上的典型應用。本質上來看，快速排序應該算是在氣泡排序基礎上的遞迴分治法。
"快速排序"的思想很簡單，整個排序過程只需要三步：
1.在資料集之中，選擇一個元素作為"基準"（pivot）。
2.所有小於"基準"的元素，都移到"基準"的左邊；所有大於"基準"的元素，都移到"基準"的右邊。
3.對"基準"左邊和右邊的兩個子集，不斷重複第一步和第二步，直到所有子集只剩下一個元素為止。

function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;

    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

function partition(arr, left ,right) {     //分割槽操作
    var pivot = left,                      //設定基準值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }        
    }
    swap(arr, pivot, index - 1);
    return index-1;
}

function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

本文來自部落格園，作者：starking_front-end，轉載請註明原文連結：https://www.cnblogs.com/starking-985/p/15965129.html