ソートアルゴリズムJS

1. バブルソート
2. 選択ソート
3. 挿入ソート
4. シェルソート
5. マージソート
6. クイック
7. カウントシング
8. ヒープソート

1.バブルソート

配列決定法の2つの隣接する要素の解析は、スイッチの位置がより大きく
複雑：O（N ^ 2）
例：[24531]> [24315]> [23145]> 2 1345]> [12345]

// 冒泡排序
function bubbleSort(arr) {
    let len = arr.length-1;
    for (let i=0; i<len; i++) {
        for (let j=0; j<len-i; j++) {
            if (arr[j] > arr[j+1]) { // 大于则交换两个的位置
                let temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr;
}

2. [ソート

配列決定方法：最小値を取得するために、各決意、位置切り替え
複雑さ：O（N ^ 2）
例：[24531]> [13532]> [12534]> [ 12354]> [12345]

// 选择排序
function selectionSort(arr) {
    let len = arr.length;
    let minIndex, temp;
    for (let i=0; i<len; i++) {
        minIndex = i;
        for (let j=i+1; j<len; j++) {
            if (arr[minIndex] > arr[j]) {
                minIndex = j; // 保存最小值索引
            }
        }
        // 进行互换位置
        temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
    return arr;
}

3.挿入ソート

小規模アプリケーションとデータ3w-順序付け
ソートアイデア：アレイは、二つに分割され、一方が既にソートされ、それは、比較するソートソートされる要素との良好な要素の、の一種である適切な位置に挿入することです。
複雑：より高いO（N ^ 2）規則化度、速い
例：[2] [4531]> [24] [531]> [245] [31]> [ 2 3 4 5] [1]> [12345]

// 插入排序
function insertionSort(arr) {
    let len = arr.length;
    let prev, cur;

    for (let i = 1; i < len; i++) {
        prev = i - 1;
        cur = arr[i];
        while (prev>=0 && arr[prev]>cur) {
            arr[prev+1] = arr[prev];
            prev--;
        }
        arr[prev+1] = cur;
    }
    return arr;
}

4.シェルソート

中規模データ100,000 +
配列決定法異なる間隔にアレイ分割、各インターバル挿入ソートし、最後にすべてのプライマリ挿入ソートの：
複雑：オーダーはO（n ^ 1.5）の度合いが高いです早く

            let len = arr.length;
            let h = Math.floor(len/2);
            // while (h < len / 3) { h = 3 * h + 1 };
            while (h >= 1) {
                for (let i = h; i < len; i++) {
                    for (let j = i; j >= h && arr[j] < arr[j - h]; j -= h) {
                        let t = arr[j];
                        arr[j] = arr[j - h];
                        arr[j - h] = t;
                    }
                }
                h = Math.round(h / 3);
            }
            return arr;

5.マージソート

配列決定方法：最小単位にアレイ分割は、挿入比べ
複雑さ O（nlogn）：
例：[24531]> [2] [4] [5] [3] [1]> [24 ] [5] [3] [1]> [245] [3] [1]> [2345] [1]> [12345]。左から右に集約比較

// 归并排序
function mergeSort(arr) {
    if (arr.length < 2) {
        return arr;
    }
    let middle = Math.floor(arr.length/2);
    let left = arr.slice(0, middle);
    let right = arr.slice(middle);

    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    let 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;
}

6.クイックソート

ソートアイデアは：右大で、左側の基準値未満、基準値を取り、最終的には約マージ、この操作を続けます。
複雑：O（nlogn）
実施例：[24351]> [21] + [3] + [45]> [1] + [2] + [3] + [4] + [5]

// 快速排序
function quickSort (arr) {
    if (arr.length < 2) { // 数组元素只有一个的时候
        return arr;
    }
    let pivotIndex = Math.floor(arr.length/2);
    let pivot = arr.splice(pivotIndex,1)[0]; // 基准值
    let left = [], // 存放比基准值小的
        right = []; // 存放比基准值大的
    arr.forEach(item=>{
        if (item <= pivot) {
            left.push(item);
        } else {
            right.push(item);
        }
    })
    return quickSort(left).concat([pivot], quickSort(right));
}

7.カウントシーケンシング

メソッド配列決定する別の配列への配列のインデックス値を、その後、取り出しました：。時間の典型的なスペース。
複雑：O（N + M）Mは元素の最大値であり、
例えば：

function countingSort(arr) {
    let bucket = [],
        sortedIndex = 0;
        arrLen = arr.length;

    for (let i = 0; i < arrLen; i++) { // 拿到数组的值当索引
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }

    for (let i = 0,len=bucket.length; i < len; i++) {
        while(bucket[i] > 0) { // 拿到索引填充到数组中
            arr[sortedIndex] = i;
            sortedIndex++;
            bucket[i]--;
        }
    }

    return arr;
}

8.ヒープソート

ソートアイデアは：第1の最大ヒープ、アレイを介して、ループを構築するために、最大の要素は、の終わりになります
複雑：O（nlogn）

            function heapSort(arr) {
                let len = arr.length;
                function maxHeapify(i) {
                    let left = 2 * i + 1;
                    let right = 2 * i + 2;
                    let largest = i;

                    if (left < len && arr[left] > arr[largest]) {
                        largest = left;
                    }
                    if (right < len && arr[right] > arr[largest]) {
                        largest = right;
                    }
                    if (largest != i) {
                        swap(i, largest);
                        maxHeapify(largest);
                    }
                }
                function swap(i, j) {
                    let t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }
                // 构建堆
                for (let i = Math.floor(len/2) - 1; i >= 0; i--) {
                    maxHeapify(i);
                }
              // 大-> 小
                for (let i = arr.length - 1; i > 0; i--) {
                    swap(0, i);
                    len--;
                    maxHeapify(0);
                }
                /* 小->大
                for (let i = 0; i < len; i++) {
                    maxHeapify(i);
                }
              */
                return arr;
            }