1. アルゴリズムの分類
10 個の一般的な並べ替えアルゴリズムは、次の 2 つの大きなカテゴリに分類できます。
- クラスの順序を比較します。
- 要素の相対的な順序を比較によって決定します。
- 時間計算量を突破できないため
O(nlogn)、非線形時間比較ソートとも呼ばれます。
- 非比較ソート:
- 要素の相対的な順序は比較によって決定されません
- 比較ベースの並べ替えの時間下限を突破して線形時間で実行できるため、線形時間非比較並べ替えとも呼ばれます。
2. 従来の並べ替えアルゴリズムの概要
10 の古典的なアルゴリズムは次のとおりです。
-
バブルソート
- バブル ソート (バブル ソート) は交換ベースのソートです
- 並べ替える必要がある要素をトラバースするたびに、隣接する 2 つの要素のサイズを順番に比較します。前の要素が後の要素より大きい場合は、2 つを交換して、最後の数値が最大になるようにします (次のように仮定します)。小さいものから大きいものまで分類されています
- つまり、最後の要素はソートされており、次のラウンドでは最初の n-1 要素の順序を確認するだけで済みます。
プロセスのデモ: ソートされる配列 {5, 4, 7, 1, 6, 2}、昇順でソート
アルゴリズムのステップ:
- 隣接する要素を比較します。最初の値が 2 番目の値より大きい場合は、両方を交換します。
- 隣接する要素の各ペアに対して、最初の最初のペアから最後の最後のペアまで同じことを行い、最後の要素が最大の数値になるようにします。
- 最後の要素を除くすべての要素に対して上記の手順を繰り返します。
- 並べ替えが完了するまで手順 1 ～ 3 を繰り返します。
- 選択ソート
- 前述のバブルソートは比較のたびに最後の要素を決定するものであり、途中の処理は常に入れ替わる。
- 選択ソートでは、残りの要素の中から最小の要素を毎回選択し、すべてのインデックス位置が選択されるまで、現在のインデックス位置の要素と交換します。
【アルゴリズム手順】nレコードを直接選択してソートすることn-1で、順序付けされた結果を得ることができます。具体的なアルゴリズムは次のように説明されます。
- 初期状態: 順序付けされていない領域は
R[1..n]、順序付けされた領域は空です。 - 最初の
iソート ( ) の開始時、現在の順序付き領域と順序なし領域はi=1,2,3…n-1それぞれR[1..i-1]とですR(i..n）。- このソート処理は、現在の順序なし領域から最小のキーを持つレコードを選択し、それを
R[k]順序なし領域の1最初のレコード R と交換します。 - 作成する
R[1..i]とはそれぞれ、R[i+1..n)レコード数が1 増加した新しい順序付けられた領域と、レコード数が 1 減少した新しい無秩序領域になります。
- このソート処理は、現在の順序なし領域から最小のキーを持つレコードを選択し、それを
n-1パスの最後に、配列がソートされます。
- 挿入ソート
- 選択ソートとは、毎回最小のものを選択し、配置された配列の後ろに置くことです。
- 挿入ソートでは、要素を順番に選択し、それを前にソートした配列の中央に挿入して、要素が正しい位置にあることを確認します。
- もちろん、これにはソートされた配列の絶え間ない移動が必要です。
【アルゴリズム手順】 一般的に、挿入ソートは配列に対してインプレースで実装されます。具体的なアルゴリズムは次のように説明されます。
- 最初の要素から始めて、要素はソートされていると見なされます。
- 次の要素を取り出し、ソートされた要素シーケンスを後ろから前にスキャンします。
- (ソートされた) 要素が新しい要素より大きい場合は、要素を次の位置に移動します。
- 並べ替えられた要素が新しい要素以下になる位置が見つかるまで、手順 3 を繰り返します。
- その位置に新しい要素を挿入した後。
- 手順2～5を繰り返します。
- ヒルソート_
- Shell's Sort は、「 Diminishing Increment Sort」とも呼ばれ、挿入ソートのより効率的かつ改良されたバージョンです。
- 挿入ソートの問題点は、順序がほとんど揃っているかどうかに関係なく、要素が比較されることです。最小数が配列の最後にある場合、それを配列の先頭に移動するのがより手間がかかります。
- ヒル ソートは、配列内でジャンプ グループ化を使用し、特定の増分ギャップに従ってグループ化し、それをいくつかのグループに分割し、各グループに対して挿入ソートを実行します。
- その後、徐々に差を減らしていきます
- 挿入ソートはグループごとに実行され、増分が 1 になるまで処理が繰り返されます。
[アルゴリズムの手順] まず、直接挿入ソートのために、ソート対象のレコード シーケンス全体をいくつかのサブシーケンスに分割します。具体的なアルゴリズムの説明は次のとおりです。
- ;
t1，t2，…，tkの場合、一連の増分を選択します。ti > tjtk = 1 - インクリメンタルシーケンスの数に応じて
k、シーケンスk時間を並べ替えます。 - 各ソートでは、対応する increment に従って
ti、ソート対象の列が length のいくつかのサブシーケンスに分割されm、各サブテーブルで直接挿入ソートが実行されます。- 増分係数が の場合のみ
1、シーケンス全体がテーブルとして扱われ、テーブルの長さがシーケンス全体の長さになります。
- 増分係数が の場合のみ
- クイックソート
- クイック ソートの方が興味深いです。配列内の数値を参照番号として選択し、1 回のパスでソートし、配列を 2 つの部分に分割します。
- 一部はベンチマーク以下、またはベンチマークと同等です
- 他の部分はベンチマーク数値以上です。
- 次に、配列が整うまでベンチマーク数値の左部分と右部分のソートを続けます。これは分割統治の考え方を体現しており、穴を掘って数字を埋める戦略にも適用されます。
- クイック ソートの方が興味深いです。配列内の数値を参照番号として選択し、1 回のパスでソートし、配列を 2 つの部分に分割します。
[アルゴリズム手順] クイックソートは、分割統治法を使用して文字列 (リスト) を 2 つの部分文字列 (サブリスト) に分割します。具体的なアルゴリズムは次のように説明されます。
- シーケンスから「ピボット」と呼ばれる要素を選択します。
- シーケンスを並べ替えます。基準値より小さいすべての要素は基準値の前に配置され、基準値より大きいすべての要素は基準値の後ろに配置されます(どちらの側にも同じ番号を配置できます)。
- このパーティションが終了すると、ベンチマークはシーケンスの途中になります。これはパーティション操作と呼ばれます。
- 基本値より小さい要素を含む部分配列と、基本値より大きい要素を含む部分配列を再帰的に並べ替えます。
- マージソート
- 前のクイック ソートは分割統治のアイデアを具体化していますが、典型的なものではありません
- マージ ソートは、非常に典型的な分割統治戦略です。マージの一般的な考え方は、まず配列を分割し、次に分割することです。
- それは 1 つの要素に分割され、部分的な順序を達成するためにペアでマージおよびソートされ、配列がすべて再度結合されるまで継続的にマージされます。
アルゴリズムのステップ
- length の
n入力シーケンスをlength の2 つのn/2サブシーケンスに分割します。 - 2 つのサブシーケンスにそれぞれマージ ソートを使用します。
- 2 つのソートされたサブシーケンスを最終的なソートされたシーケンスにマージします。
- バケットソート
- バケットの並べ替えとは、要素を保存するために複数のバケットを使用することを指し、各バケットには保存範囲があります。
- まず、範囲に従って各バケットに要素を配置します。各バケットはサブ配列であり、次に各サブ配列をソートし、最後にサブ配列をマージして最終的な順序付けされた配列になります。
- これは実際には計数ソートと非常によく似ていますが、計数ソートでは各バケットに要素が 1 つだけあり、バケットに格納される値が要素の出現数である点が異なります。
アルゴリズムのステップ
- 定量的配列を空のバケットとして設定します。
- 入力データを走査し、データを 1 つずつ対応するバケット。
- 空ではない各バケットを並べ替えます。
- 空ではないバケットからソートされたデータを連結します。
- ヒープソート_
- ヒープ ソートは、大きなトップ ヒープまたは小さなトップ ヒープを使用して設計されたソート アルゴリズムであり、選択ソートです。
- ヒープは完全なバイナリ ツリーです。
- ビッグトップヒープ: 各ノードの値は、その左右の子ノードの値以上です。
- 小さな上部ヒープ: 各ノードの値は、その左右の子ノードの値以下です。
アルゴリズムのステップ:
- 並べ替えられるキーワードの最初のシーケンスを、最初の順序付けされていない領域である大きな上部ヒープに
(R1,R2….Rn)構築します。 - ヒープの先頭要素
R[1]と最後の要素を交換しR[n]、この時点で新しい非順序領域(R1,R2,……Rn-1)と新しい順序領域を取得し(Rn)、満たしますR[1,2…n-1]<=R[n]。 - 交換後の新しいヒープトップはヒープの性質に反する可能性があるため、現在の非順序領域を新しいヒープに調整し、最後の要素を再度非順序領域と交換して、新しい非順序領域と新しいヒープを取得する
R[1]必要があります。注文したエリア。(R1,R2,……Rn-1)R[1](R1,R2….Rn-2)(Rn-1,Rn) - ソート領域内の要素の数が になるまでこのプロセスを繰り返し
n-1、ソート プロセス全体が完了します。
- カウントソート
- 比較ではなくカウントに基づいてソートをカウントする
- 要素の値が類似しており、整数である場合に適しています。
アルゴリズムのステップ
- 並べ替える配列内の最大要素と最小要素を見つけます。
i配列内の各値を持つ要素の出現数をカウントし、配列 C の最初の項目に格納しますi。- すべてのカウントを累積します(最初の要素
Cから、各項目が前の項目に追加されます)。 - ターゲット配列を逆に埋めます。各要素 i を新しい配列の item に置き、
C(i)配置された要素ごとにC(i)1 を減算します。
- 基数ソート
- カーディナリティ ソートは、整数 (自然数) のソートにのみ使用でき、比較に基づいていないという点で特殊です。
- 原理は、整数を桁に応じて異なる数値に分割し、各桁の値に従って段階的に並べ替えることです。
- 81 などの上位ビットは何ですか。1 が下位ビット、8 が上位ビットです。
- 上位優先と下位優先に分かれており、上位を先に比較するのが上位優先、下位を先に比較するのが下位優先となります。
アルゴリズムのステップ:
- 配列内の最大数を取得し、桁数を取得します。
arr元の配列の場合、各ビットは最下位ビットから取得されてradix配列が形成されます。radixカウントとソート(カウントソートの使用は、狭い範囲の数値に適しています)。
3. アルゴリズムの複雑さ
一般的な並べ替えアルゴリズムの複雑さ
関連概念
- 安定: a が元々 b の前にあり、a=b の場合、ソート後も a は b の前にあります。
- 不安定: a が元々 b の前にあり、a=b の場合、ソート後に a が b の後ろに現れる可能性があります。
- 時間計算量:並べ替えられたデータに対する操作の合計数。これは、n が変化するときの操作数の規則性を反映しています。
- スペース複雑度:アルゴリズムがコンピュータで実行されるときに必要なストレージ スペースの測定値を指し、データ サイズ n の関数でもあります。
4. コードの実装
- バブルソート
function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
for (var j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
// 相邻元素两两对比
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];
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;
}
- シェルソート（シェルソート）
function shellSort(arr) {
var len = arr.length;
for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
// 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行
for (var i = gap; i < len; i++) {
var j = i;
var current = arr[i];
while (j - gap >= 0 && current < arr[j - gap]) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
}
return arr;
}
- マージソート
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>0 && right.length>0) {
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;
}
- クイックソート（クイックソート）
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;
}
- ヒープソート
var len; // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
function buildMaxHeap(arr) {
// 建立大顶堆
len = arr.length;
for (var i = Math.floor(len/2); i >= 0; i--) {
heapify(arr, i);
}
}
function heapify(arr, i) {
// 堆调整
var left = 2 * i + 1,
right = 2 * i + 2,
largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest);
}
}
function swap(arr, i, j) {
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function heapSort(arr) {
buildMaxHeap(arr);
for (var i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0);
}
return arr;
}
- カウンティングソート
function countingSort(arr, maxValue) {
var bucket = new Array(maxValue + 1),
sortedIndex = 0;
arrLen = arr.length,
bucketLen = maxValue + 1;
for (var i = 0; i < arrLen; i++) {
if (!bucket[arr[i]]) {
bucket[arr[i]] = 0;
}
bucket[arr[i]]++;
}
for (var j = 0; j < bucketLen; j++) {
while(bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return arr;
}
- バケットソート
function bucketSort(arr, bucketSize) {
if (arr.length === 0) {
return arr;
}
var i;
var minValue = arr[0];
var maxValue = arr[0];
for (i = 1; i < arr.length; i++) {
if (arr[i] < minValue) {
minValue = arr[i]; // 输入数据的最小值
} else if (arr[i] > maxValue) {
maxValue = arr[i]; // 输入数据的最大值
}
}
// 桶的初始化
var DEFAULT_BUCKET_SIZE = 5; // 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
var buckets = new Array(bucketCount);
for (i = 0; i < buckets.length; i++) {
buckets[i] = [];
}
// 利用映射函数将数据分配到各个桶中
for (i = 0; i < arr.length; i++) {
buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
}
arr.length = 0;
for (i = 0; i < buckets.length; i++) {
insertionSort(buckets[i]); // 对每个桶进行排序，这里使用了插入排序
for (var j = 0; j < buckets[i].length; j++) {
arr.push(buckets[i][j]);
}
}
return arr;
}
- 基数ソート (基数ソート)
var counter = [];
function radixSort(arr, maxDigit) {
var mod = 10;
var dev = 1;
for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
for(var j = 0; j < arr.length; j++) {
var bucket = parseInt((arr[j] % mod) / dev);
if(counter[bucket]==null) {
counter[bucket] = [];
}
counter[bucket].push(arr[j]);
}
var pos = 0;
for(var j = 0; j < counter.length; j++) {
var value = null;
if(counter[j]!=null) {
while ((value = counter[j].shift()) != null) {
arr[pos++] = value;
}
}
}
}
return arr;
}
