8つのソートアルゴリズムのPython実装

この記事では、主に 8 つの一般的なソート アルゴリズムの基本概念とそれらの Python 実装を紹介します。Javaプログラマーの場合は、以前に紹介した Java プログラマーが習得しなければならない 8 つのソート アルゴリズムもご覧ください。

1. 挿入ソート

説明する

挿入ソートの基本的な操作は、ソートされた順序付きデータにデータを挿入し、番号が 1 つ増加した新しい順序付きデータを取得することです。このアルゴリズムは少量のデータのソートに適しており、時間の計算量は O(n^2) です。安定した選別方法です。挿入アルゴリズムは、ソートする配列を 2 つの部分に分割します。最初の部分には、最後の要素を除く配列のすべての要素が含まれ (配列に挿入用のスペースをもう 1 つ確保するため)、2 番目の部分にはこの要素 (つまり、挿入する要素) のみが含まれます。 *** 部分がソートされたら、この *** 要素をソートされた *** 部分に挿入します。

コードの実装

def insert_sort(リスト):
    挿入ソート
    count = len(リスト)
 i が範囲( 1 、カウント)内にある場合:
        キー = リスト[i]
        j = i - 1  
 j >= 0の場合:
リスト[j] > キーの場合:
                リスト[j + 1 ] = リスト[j]
                リスト[j] = キー
            1 -= 1 です 
リターンリスト

2. シェルソート

説明する

シェルソートは挿入ソートの一種です。縮小増分ソートとも呼ばれるこのソートは、直接挿入ソート アルゴリズムのより効率的な改良版です。シェルソートは不安定なソートアルゴリズムです。この方法はDLによるものです。 Shell は 1959 年に提案されたことにちなんで命名されました。 シェルソートは、インデックスの特定の増分に従ってレコードをグループ化し、直接挿入ソートアルゴリズムを使用して各グループをソートします。増分が徐々に減少するにつれて、各グループに含まれるキーワードの数が増えていきます。増分が 1 に減少すると、ファイル全体が 1 つのグループに分割され、アルゴリズムが終了します。

コードの実装

def shell_sort(リスト):
    # シェルソート
    count = len(リスト)
    ステップ = 2  
    グループ = カウント / ステップ
グループ > 0の場合:
 i が範囲( 0 、グループ)内にある場合:
            j = i + グループ
j < カウントの場合:
                k = j - グループ
                キー = リスト[j]
 k >= 0の場合:
リスト[k] > キーの場合:
                        リスト[k + グループ] = リスト[k]
                        リスト[k] = キー
                    k -= グループ
                j += グループ
        グループ /= ステップ
リターンリスト

3. バブルソート

説明する

ソートする配列を繰り返し処理し、一度に 2 つの要素を比較して、順序が間違っている場合はそれらを交換します。シーケンスを訪問する作業は、交換が不要になるまで、つまりシーケンスがソートされるまで繰り返されます。

コードの実装

def bubble_sort(リスト):
    # バブルソート
    count = len(リスト)
 i が範囲( 0 、カウント)内にある場合:
 j が範囲(i + 1 、カウント)内にある場合:
リスト[i] > リスト[j]の場合:
                リスト[i]、リスト[j] = リスト[j]、リスト[i]
リターンリスト

4. クイックソート

説明する

ソート パスにより、ソートするデータは 2 つの独立した部分に分割され、一方の部分のすべてのデータはもう一方の部分のすべてのデータよりも小さくなります。次に、この方法に従って、2 つの部分のデータが別々にすばやくソートされます。ソート プロセス全体を再帰的に実行して、データ全体を順序付けられたシーケンスに変換できます。

コードの実装

def quick_sort(リスト、左、右):
    # クイックソート
左 >= 右の場合:
リターンリスト
    キー = リスト[左]
    低い = 左
    高い = 右
左 < 右の場合:
 left < right かつ lists[right] >= key の場合:
            右 -= 1  
        リスト[左] = リスト[右]
 left < right かつ lists[left] <= key の場合:
            左 += 1  
        リスト[右] = リスト[左]
    リスト[右] = キー
    quick_sort(リスト、low、left - 1 )
    quick_sort(リスト、左 + 1 、高)
リターンリスト

5. 直接選択ソート

説明する

基本的な考え方: 最初のパスでは、ソートする r1 ~ r[n] から最小のレコードを選択し、それを r1 と交換します。2 番目のパスでは、ソートする r2 ~ r[n] から最小のレコードを選択し、それを r2 と交換します。以下同様に行います。i 番目のパスでは、ソートする r[i] ~ r[n] から最小のレコードを選択し、それを r[i] と交換します。これにより、すべてのレコードがソートされるまで、順序付けられたシーケンスが拡大し続けます。

コードの実装

def select_sort(リスト):
    # 選択ソート
    count = len(リスト)
 i が範囲( 0 、カウント)内にある場合:
        最小 = i
 j が範囲(i + 1 、カウント)内にある場合:
リスト[min] > リスト[j]の場合:
                最小 = j
        リスト[最小]、リスト[i] = リスト[i]、リスト[最小]
リターンリスト

6. ヒープソート

説明する

ヒープソートとは、ヒープツリー（ヒープ）のデータ構造を使用して設計されたソートアルゴリズムを指します。選択ソートの一種です。配列の特性を利用すると、指定したインデックスの要素をすばやく見つけることができます。ヒープは、完全なバイナリ ツリーである大きなルート ヒープと小さなルート ヒープに分割されます。ビッグ ルート ヒープの要件は、各ノードの値が親ノードの値以下であること、つまり A[PARENT[i]] >= A[i] です。配列の非降順ソートでは、ビッグ ルート ヒープが使用されます。これは、ビッグ ルート ヒープの要件に従って、最小の値がヒープの最上部にある必要があるためです。

コードの実装

# ヒープを調整する
def adjust_heap(リスト、i、サイズ):
    lchild = 2 * i + 1  
    rchild = 2 * i + 2  
    最大 = i
 i < サイズ / 2 の場合:
 lchild < size かつlists[lchild] > lists[max]の場合:
            最大 = lchild
 rchild < size かつlists[rchild] > lists[max]の場合:
            最大 = rchild
最大値!= iの場合:
            リスト[max]、リスト[i] = リスト[i]、リスト[max]
            adjust_heap(リスト、最大、サイズ) 
 
 # ヒープを作成する
def build_heap(リスト、サイズ):
 i が範囲( 0 、(size/ 2 ))[::- 1 ] の場合:
        adjust_heap(リスト、i、サイズ) 
 
 # ヒープソート
def heap_sort(リスト):
    サイズ = len(リスト)
    build_heap(リスト、サイズ)
 i が範囲( 0 、サイズ)[::- 1 ]の場合:
        リスト[ 0 ]、リスト[i] = リスト[i]、リスト[ 0 ]
        ヒープを調整する(リスト、 0 、i)

7. マージソート

説明する

マージ ソートは、マージ操作に基づいた効果的なソート アルゴリズムです。このアルゴリズムは、分割統治法の非常に典型的な応用です。順序付けられたサブシーケンスをマージして、完全に順序付けられたシーケンスを取得します。つまり、最初に各サブシーケンスを順序付けし、次にサブシーケンスのセグメントを順序付けます。 2 つの順序付きリストが 1 つの順序付きリストに結合される場合は、双方向結合と呼ばれます。

マージのプロセスは、a[i]とa[j]のサイズを比較することです。a[i]≤a[j]の場合、最初の順序付きリストの要素a[i]をr[k]にコピーし、iとkにそれぞれ1を加算します。それ以外の場合は、2番目の順序付きリストの要素a[j]をr[k]にコピーし、jとkにそれぞれ1を加算します。順序付きリストの1つがなくなるまでこのサイクルを繰り返し、次に、もう1つの順序付きリストの残りの要素をrの添え字kから添え字tまでのユニットにコピーします。通常、マージソートアルゴリズムは再帰的に実装します。まず、ソートする区間 [s, t] を中間点で 2 つに分割し、次に左のサブ区間をソートし、次に右のサブ区間をソートします。最後に、マージ操作によって左の区間と右の区間を順序付けられた区間 [s, t] にマージします。

コードの実装

def merge(左、右):
    i,j = 0 , 0  
    結果 = []
 i < len(左)かつj < len(右)の場合:
左[i] <= 右[j]の場合:
            結果.append(左[i])
            私 += 1  
それ以外：
            結果.append(右[j])
            1 + = 1  
    結果 += 左[i:]
    結果 += 右[j:]
結果を返す
 
 def merge_sort(リスト):
    # マージソート
len(リスト) <= 1 の場合:
リターンリスト
    num = len(リスト) / 2  
    左 = merge_sort(リスト[:num])
    右 = merge_sort(リスト[num:])
マージを返す(左、右)

8. 基数ソート

説明する

基数ソートは「分散ソート」に属し、「バケット ソート」または「ビン ソート」とも呼ばれます。名前が示すように、キー値の部分的な情報を使用して、ソートする要素を特定の「バケット」に分散し、ソート効果を実現します。基数ソートは、時間計算量が O (nlog(r)m) の安定したソートです。ここで、r は基数、m はヒープの数です。場合によっては、基数ソートは他の安定したソート方法よりも効率的です。

コードの実装

インポート数学
定義radix_sort(リスト、基数= 10 ):
    k = int (math.ceil(math.log(max(lists), radix)))
    バケット = [[] iが範囲(基数)]
 iが範囲( 1 ,k+ 1 )内にある場合:
リスト内のjの場合:
            バケット[j/(radix**(i- 1 )) % (radix**i)].append(j)
        リストを削除する[:]
バケット内のzの場合:
            リスト += z
            del z[:]
リターンリスト