トップ10のソートアルゴリズムの複雑さと安定性の属性テーブル
絵の名詞の説明：
n：データサイズ
k：「バケット」の数
インプレース：一定のメモリを占有し、追加のメモリを占有しない
アウトプレース：追加のメモリを占有する
1.バブルソート（バブルソート）
バブルソートアルゴリズムの原理は次のとおりです。
a。隣接する要素を比較します。最初のものが2番目のものよりも大きい場合は、2つを交換します。
-
B。最後の最後のペアに初めに最初のペアから、隣接する要素のペアごとに同じ作業を行います。この時点で、最後の要素が最大数になるはずです。
-
C。最後の1以外のすべての要素について、上記の手順を繰り返します。
-
D比較する数値のない組がなくなるまで少なくなり要素たびに上記の手順を繰り返し。
複雑さと安定性：
時間の複雑さ：O（n ^ 2）
空間の複雑さ：O（1）
安定性：老犬として安定、内部ソート
Python実装コード：
def bubble_sort(nums):
n = len(nums)
# 进行多次循环
for c in range(n):
for i in range(1, n - c):
if nums[i - 1] > nums[i]:
nums[i - 1], nums[i] = nums[i], nums[i - 1]
return nums
2. [並べ替え]を選択します
各パスでは、並べ替えるデータ要素から最小（最大）の要素が選択され、並べ替えるすべてのデータ要素が配置されるまで、並べ替える数列の先頭にシーケンスが配置されます。
例：
[4、2、3]最小の要素を見つける：2、最初の要素と交換する
[ 2、4、3]最小の要素を見つける：3、2番目の要素と交換する
[2、3、4]
複雑さと安定性：
時間の複雑さ：O（n ^ 2）
空間の複雑さ：O（1）
安定性：安定したリンクリスト、不安定な配列、内部ソート
Python実装コード：
def select_sort(nums):
n = len(nums)
for i in range(n):
for j in range(i, n):
if nums[i] > nums[j]:
nums[i], nums[j] = nums[j], nums[i]
return nums
3.挿入ソート（挿入ソート）
コアアイデア：挿入ソートは、以前にソートされた配列内の挿入位置を見つけることです
複雑さと安定性：
時間の複雑さ：O（n ^ 2）
空間の複雑さ：O（1）
安定性：老犬として安定、内部ソート
Python実装コード：
def insertion_sort(nums):
n = len(nums)
for i in range(1, n):
while i > 0 and nums[i - 1] > nums[i]:
nums[i - 1], nums[i] = nums[i], nums[i - 1]
i -= 1
return nums
4.ヒルソート（シェルソート）
挿入ソートの高度なバージョン。。。
アルゴリズムの説明：
ヒルソートの基本的な手順を見てみましょう。ここでは、増分ギャップ=長さ/ 2を選択し、縮小増分はギャップ=ギャップ/ 2で続行します。この増分選択はシーケンス{n / 2、 （n / 2）/ 2 ... 1}、インクリメンタルシーケンスと呼ばれます。ヒルソートのインクリメンタルシーケンスの選択と証明は数学的な問題です。選択するインクリメンタルシーケンスがより一般的に使用され、ヒルインクリメンタルと呼ばれるヒルによって提案されたインクリメンタルでもありますが、実際には、このインクリメンタルシーケンスは最も優れています。
最初に、ソートされるレコードのシーケンス全体をいくつかのサブシーケンスに分割して、直接挿入ソートを行います。具体的なアルゴリズムの説明は次のとおりです。
ステップ1：インクリメントシーケンスt1、t2、...、tkを選択します。ここで、Ti> TJ、TK = 1;
-
ステップ2：シーケンス番号k、kをシーケンスがソートされる回数インクリメントします;
-
ステップ3：各ソートでパス、対応する増分tiに従って、ソートされるシーケンスは長さmのいくつかのサブシーケンスに分割され、各サブテーブルが直接挿入されてソートされます。インクリメントファクターが1の場合のみ、シーケンス全体がテーブルとして扱われ、テーブルの長さはシーケンス全体の長さになります。
複雑さと安定性：
時間の複雑さ：O（nlogn）
スペースの複雑さ：O（n）
安定性：非常に安定した外部ソーティング（追加のスペースが必要）
Python実装コード：
def shell_sort(nums):
n = len(nums)
gap = n // 2
while gap:
for i in range(gap, n):
while i - gap >= 0 and nums[i - gap] > nums[i]:
nums[i - gap], nums[i] = nums[i], nums[i - gap]
i -= gap
gap //= 2
return nums
5.マージソート（マージソート）
マージソートは分割統治法を採用しており、まず配列をサブシーケンスに分割してサブシーケンスを順番に作成し、次にサブシーケンスを順序付けてマージして順序付き配列にします。
アルゴリズムの説明：
1.長さnの入力シーケンスを長さn / 2のサブシーケンスに分割します;
2。2つのサブシーケンスでマージソートを使用します;
3。すべてのサブシーケンスをマージします。
複雑さと安定性：
時間の複雑さ：O（nlogn）
空間の複雑さ：O（1）
安定性：不安定な内部ソート
Python実装コード：
def merge_sort(nums):
if len(nums) <= 1:
return nums
mid = len(nums) // 2
# 分
left = merge_sort(nums[:mid])
right = merge_sort(nums[mid:])
# 合并
return merge(left, right)
def merge(left, right):
res = []
i = 0
j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
res.append(left[i])
i += 1
else:
res.append(right[j])
j += 1
res += left[i:]
res += right[j:]
return res
6.クイックソート（クイックソート）
クイックソートでは、「センチネル」（ピボット）を選択し、左側にピボットより小さく、右側にピボットより大きく配置し、2つの部分に分割して、配列内のピボットの位置を固定し、引き続き並べ替えます。左右のパーツ。
クイックソートは分割統治法を使用して、リストを2つのサブリストに分割します。具体的なアルゴリズムは次のとおりです。
ステップ1：「参照」（ピボット）と呼ばれる、要素の列の数を選ぶ;
-
ステップ2：並べ替え列、基準値よりも基準小の前に置かれたすべての要素を、基準値よりも大きいですベンチマークの背後にあるスイングのすべての要素（同じ数がどちらの側にも行くことができます）。パーティションが終了した後、ベンチマークはシーケンスの途中にあります。これは、パーティション（パーティション）動作と呼ばれている;
-
ステップ3：再帰基準値よりも列の数とサブ要素の列の数要素のソート基準値よりも大きい場合（これを再帰的）。
複雑さと安定性：
時間の複雑さ：O（nlogn）
空間の複雑さ：O（1）
安定性：不安定な内部ソート
Python実装コード：
def quick_sort(nums):
n = len(nums)
def quick(left, right):
if left >= right:
return nums
pivot = left
i = left
j = right
while i < j:
while i < j and nums[j] > nums[pivot]:
j -= 1
while i < j and nums[i] <= nums[pivot]:
i += 1
nums[i], nums[j] = nums[j], nums[i]
nums[pivot], nums[j] = nums[j], nums[pivot]
quick(left, j - 1)
quick(j + 1, right)
return nums
return quick(0, n - 1)
7、ヒープソート（ヒープソート）
ヒープソートは、ヒープのデータ構造を使用して設計されたソートアルゴリズムです。
アルゴリズムの説明：
1.杭を作成し、親ノードの値が子ノードよりも大きくなるように杭を下から上に調整して、大きな上部杭を形成します
。2。杭の上部と最後の要素を交換し、パイル。
調整ヒープメソッドには、非常に理解しやすい再帰と反復が記述されています。
複雑さと安定性：
時間の複雑さ：O（nlogn）
空間の複雑さ：O（1）
安定性：不安定な内部ソート
Python実装コード：
def heap_sort(nums):
# 调整堆
# 迭代写法
def adjust_heap(nums, startpos, endpos):
newitem = nums[startpos]
pos = startpos
childpos = pos * 2 + 1
while childpos < endpos:
rightpos = childpos + 1
if rightpos < endpos and nums[rightpos] >= nums[childpos]:
childpos = rightpos
if newitem < nums[childpos]:
nums[pos] = nums[childpos]
pos = childpos
childpos = pos * 2 + 1
else:
break
nums[pos] = newitem
# 递归写法
def adjust_heap(nums, startpos, endpos):
pos = startpos
chilidpos = pos * 2 + 1
if chilidpos < endpos:
rightpos = chilidpos + 1
if rightpos < endpos and nums[rightpos] > nums[chilidpos]:
chilidpos = rightpos
if nums[chilidpos] > nums[pos]:
nums[pos], nums[chilidpos] = nums[chilidpos], nums[pos]
adjust_heap(nums, pos, endpos)
n = len(nums)
# 建堆
for i in reversed(range(n // 2)):
adjust_heap(nums, i, n)
# 调整堆
for i in range(n - 1, -1, -1):
nums[0], nums[i] = nums[i], nums[0]
adjust_heap(nums, 0, i)
return nums
8.ソートのカウント
カウントソートは、典型的な時空間アルゴリズムであり、ストレージ用の追加のデータスペースを開き、配列の値と配列値の数をインデックス番号で記録します
アルゴリズムの説明：
1.並べ替える配列の最大値と最小値を見つけます;
2。配列値の数を数えます;
3。ターゲット配列を逆に入力します。
複雑さと安定性：
時間の複雑さ：O（n + k）
空間の複雑さ：O（k）、データ範囲が広いアレイの場合、多くの時間とメモリが必要です。
安定性：安定した外部ソート
Python実装コード：
def counting_sort(nums):
if not nums: return []
n = len(nums)
_min = min(nums)
_max = max(nums)
tmp_arr = [0] * (_max - _min + 1)
for num in nums:
tmp_arr[num - _min] += 1
j = 0
for i in range(n):
while tmp_arr[j] == 0:
j += 1
nums[i] = j + _min
tmp_arr[j] -= 1
return nums
9.バケットソート（バケットソート）
バケットソートは、カウントソートのアップグレードバージョンです。原則は、入力データが均一に分散され、データが限られた数のバケットに分割され、各バケットが個別にソートされることです（他のアルゴリズムを使用することも、引き続き使用することもできます）。再帰的バケットソート、この記事では再帰的コーディングを使用しています）
アルゴリズムの説明：
1.バケットのBucketSizeは、各バケットにいくつの異なる値が配置されるかによって人為的に設定されます（つまり、BucketSize = 5、[1、2、3,4,5]や100,000などの5つの異なる数値を入力できます3、それはちょうどバケツは、いくつかの異なる値を格納できることを意味します
）; -
2.トラバースソートするデータ、および対応するバケット内の1つのことで、データ1を置く
; -
ソート3.各非バケットのことができます。他の並べ替え方法を使用します。また、再帰的な並べ替えも使用します。
-
4、空のバケットデータをスプライシングしないでください。
複雑さと安定性：
時間の複雑さ：O（n ^ 2）
空間の複雑さ：O（n + k）
安定性：安定した、外側の秩序
Python実装コード：
def bucket_sort(nums, bucketSize):
if len(nums) < 2:
return nums
_min = min(nums)
_max = max(nums)
# 需要桶个数
bucketNum = (_max - _min) // bucketSize + 1
buckets = [[] for _ in range(bucketNum)]
for num in nums:
# 放入相应的桶中
buckets[(num - _min) // bucketSize].append(num)
res = []
for bucket in buckets:
if not bucket: continue
if bucketSize == 1:
res.extend(bucket)
else:
# 当都装在一个桶里,说明桶容量大了
if bucketNum == 1:
bucketSize -= 1
res.extend(bucket_sort(bucket, bucketSize))
return res
10.基数ソート（基数ソート）
カーディナリティソートは、数値の各桁を最下位桁からソートすることです。
アルゴリズムの説明：
1.配列の最大値を見つけて、最大桁数を取得します
。2。最下位ビットから各ビットを取得して基数配列を形成します。3。基数を
カウントして並べ替えます（カウントと並べ替えは小規模な機能に適しています） ）。
複雑さと安定性：
時間の複雑さ：O（n * k）
空間の複雑さ：O（n + k）
安定性：安定した、外側の秩序
Python実装コード：
def Radix_sort(nums):
if not nums: return []
_max = max(nums)
# 最大位数
maxDigit = len(str(_max))
bucketList = [[] for _ in range(10)]
# 从低位开始排序
div, mod = 1, 10
for i in range(maxDigit):
for num in nums:
bucketList[num % mod // div].append(num)
div *= 10
mod *= 10
idx = 0
for j in range(10):
for item in bucketList[j]:
nums[idx] = item
idx += 1
bucketList[j] = []
return nums
参照ソース：https ：//leetcode-cn.com/problems/sort-an-array/solution/python-shi-xian-de-shi-da-jing-dian-pai-xu-suan-fa/