JavaScript で実装された 7 つのソート アルゴリズムの概要 (推奨!)

定数ソート = (arr) => {
    (i = 0, len = arr.length; i < len-1; i++) の場合{
        (j = 0; j < len-1-i; j++) の場合 {
            もし(arr[j] > arr[j+1])であれば{
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
    }
    リターン
}

定数ソート = (arr) => {
    (i = 0, len = arr.length; i < len - 1; i++) の場合 {
        isSwap = false とします
        (j = 0; j < len - 1 - i; j++) の場合 {
            もし(arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                isSwap = true
            }
        }
        スワップの場合
            壊す;
        }
    }
    arr を返します。
};

定数ソート = (arr) => {
    (i = 0, len = arr.length; i < len - 1; i++) の場合 {
        minIndex = i とします
        (j = i+1; j < len; j++) の場合 {
            もし(arr[i] > arr[j]) {
                最小インデックス = j
            }
        }
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
    arr を返します。
};

定数ソート = (arr) => {
    (i = 0, len = arr.length; i < len / 2; i++) の場合 {
        minIndex = i とします。
        maxIndex = i とします。
        (j = i + 1; j < len-i; j++) の場合 {
            （arr[minIndex] > arr[j]）の場合{
                最小インデックス = j;
            }
            （arr[maxIndex] < arr[j]）の場合{
                最大インデックス = j;
            }
        }
        minIndex === maxIndexの場合、break;
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
        （最大インデックス === i）の場合{
            最大インデックス = 最小インデックス;
        }
        定数 lastIndex = len - i - 1;
        [arr[最大インデックス]、arr[最終インデックス]] = [arr[最終インデックス]、arr[最大インデックス]];
    }
    arr を返します。 
};

定数ソート = (arr) => {
    (i = 1、len = arr.length、i < len、i++ とします) {
        j = iとします。
        (j >= 1 && arr[j] < arr[j - 1]) の場合 {
            [arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
            じーー
        }
    }
    arr を返します。
};

定数ソート = (arr) => {
    (i = 1、len = arr.length、i < len、i++ とします) {
        j = i-1 とします。
        cur = arr[i]とします。
        (j >= 0 && cur < arr[j]) の間 {
            arr[j+1] = arr[j]
            j--;
        }
        arr[j+1] = cur
    }
    arr を返します。
};

定数ソート = arr => {
    定数len = arr.length;
    長さが2以下の場合
        arr を返します。
    }
    ギャップを Math.floor(len / 2) とします。
    ギャップ > 0 の場合
        (i = ギャップとします; i < len; i++) {
            j = iとします。
            cur = arr[i]とします。
            (j >= 0 && cur < arr[j - ギャップ]) {
                arr[j] = arr[j - ギャップ];
                j -= ギャップ;
            }
            arr[j] = cur;
        }
        ギャップ = Math.floor(ギャップ / 2);
    }
    arr を返します。
}

関数sort(arr) {
    (i = Math.floor(arr.length / 2) - 1 とします; i >= 0; i--) {
        ヒープを調整します(arr, i, arr.length)
    }
    (j = arr.length - 1; j > 0; j--) の場合 {
        [arr[0], arr[j]] = [arr[j], arr[0]]
        ヒープを調整(arr, 0, j)
    }
}

関数adjustHeap(arr, i, length) {
    tmp = arr[i]とする
    (k = i * 2 + 1 とします; k < 長さ; k = k * 2 + 1) {
        (k + 1 < 長さ && arr[k] < arr[k + 1]) の場合 {
            関数
        }
        （arr[k] > tmp）の場合{
            arr[i] = arr[k];
            私 = k;
        } それ以外 {
            壊す;
        }
        arr[i] = tmp;
    }
}

const パーティション = (arr, 開始, 終了) => {
    let pivot = arr[start]; // 最初の数値を基数として取得します。let left = start + 1; // 2 番目の数値から分割を開始します。let right = end; // 右境界 // left と right が出会ったらループを終了します。while (left < right) {
        // カーディナリティより大きい最初の位置を検索します while (left < right && arr[left] <= pivot) left++;
        // これら 2 つの数値を入れ替えて、左のパーティションがカーディナリティ以下になり、右のパーティションがカーディナリティ以上になるようにします。if (left != right) {
            [arr[左], arr[右]] = [arr[右], arr[左]];
            右 - ;
        }
    }
    // 左と右が等しい場合は、arr[right] と pivot を別々に比較します
    if (left == right && arr[right] > pivot) right--;
    // ベースと中央を入れ替えます if (right != start) [arr[left], pivot] = [pivot, arr[left]];
    // 中央の値の添字を返します return right;
}

const クイックソート = (arr, 開始, 終了) => {
    (開始 >= 終了) の場合、戻り値:
    const 中間 = パーティション (arr、開始、終了)
    クイックソート(arr, start, middle - 1);
    クイックソート(arr, 中間 + 1, 終了);
}

定数ソート = arr => {
    クイックソート(arr, 0, arr.length -1);
}

const マージ = (左、右) => {
    結果 = [] とします。
    （左の長さ＞0＆右の長さ＞0）{
        （左[0] <= 右[0]）の場合{
            結果をプッシュします(左にシフトします());
        } それ以外 {
            結果を右に押します。
        }
    }
    left.length を result.push(left.shift()); しながら
    right.length を result.push(right.shift()); しながら
    結果を返します。
}

定数ソート = (arr) => {
    len = arr.length;とします。
    長さが2以下の場合
        arr を返します。
    }
    const 中間 = Math.floor(len / 2)、
        左 = arr.slice(0, 中央)、
        右 = arr.slice(中央);
    merge(sort(left), sort(right)) を返します。
};