Python の 8 つの並べ替え方法

1. 挿入ソート

#-*- coding:utf-8 -*-
'''
描述
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。
是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），
而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中
'''
def insert_sort(lists):
    count = len(lists)
    for i in range(1, count):
        key = lists[i]
        j = i - 1
        while j >= 0:
            if lists[j] > key:
                lists[j + 1] = lists[j]
                lists[j] = key
            j -= 1
    return lists

lst1 = raw_input().split()
lst = [int(i) for i in lst1]
#lst = input()
insert_sort(lst)
for i in range(len(lst)):
    print lst[i],

2. バブルソート

#-*- coding:utf8 -*-
'''
描述
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，
每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
'''
def shell_sort(lists):
    count = len(lists)
    step = 2
    group = count / step
    while group > 0:
        for i in range(group):
            j = i + group
            while j < count:
                k = j - group
                key = lists[j]
                while k >= 0:
                    if lists[k] > key:
                        lists[k + group] = lists[k]
                        lists[k] = key
                    k -= group
                j += group
        group /= step
    return lists

lst1 = raw_input().split()
lst = [int(i) for i in lst1]
#lst = input()
shell_sort(lst)
for i in range(len(lst)):
    print lst[i],

5. ヒープソート

#-*- coding:utf8 -*-
'''
描述
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
'''
def bubble_sort(lists):
    count = len(lists)
    for i in range(count):
        for j in range(i + 1, count):
            if lists[i] > lists[j]:
                lists[i], lists[j] = lists[j], lists[i]
    return lists

lst1 = raw_input().split()
lst = [int(i) for i in lst1]
#lst = input()
bubble_sort(lst)
for i in range(len(lst)):
    print lst[i],

7.

8. 基数ソート

#-*- coding:utf8 -*-
'''
描述
基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；
以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
'''
def select_sort(lists):
    count = len(lists)
    for i in range(count):
        min = i
        for j in range(i + 1, count):
            if lists[min] > lists[j]:
                min = j
        lists[min], lists[i] = lists[i], lists[min]
    return lists

lst1 = raw_input().split()
lst = [int(i) for i in lst1]
#lst = input()
select_sort(lst)
for i in range(len(lst)):
    print lst[i],

以下に、さまざまなソート アルゴリズムの時間計算量と安定性の比較を示します:

平均速度が最も速いソート アルゴリズムは何ですか?

ソート方法 「O(1) 安定した

選択ソートO( n^ 2) O(n^2) O(n^2) O(1) 不安定な挿入ソート O(n^2) O(n) O (n^2) O(1) 安定

ヒルソート O(n*log(n))~O(n^2) O(n^1.3) O(n^2) O(1) 不安定

ヒープソート O(n*log(n)) O(n *log(n)) O(n*log(n)) O(1) 不安定なマージソート O(n*log(n)) O(n *log(n)) O(n*log(n) )) O(n) 安定

クイックソート O(n*log(n)) O(n*log(n)) O(n^2) O( 1) バブルソートが最適化される 将来的には、最高の時間計算量は O(n) に達する可能性があります。フラグ ビットを設定すると、比較で交換が発生しない場合は早期に終了する可能性があるため、正のシーケンスの場合、時間計算量は O(n) になります。最悪の場合と最良の場合の両方で、選択ソートでは残りのシーケンス内の最小 (最大) の数値を選択し、それをソートされたシーケンスの次の位置にある要素と交換する必要があります。 最良の時間計算量と最悪の時間計算量は両方とも O です。 (n^2)。挿入ソートは、ソートされたシーケンスの次の要素を以前にソートされたシーケンスに挿入することです (適切な位置を選択する必要があります)。正の順序の場合、時間計算量は O(n) です。ヒープは完全なバイナリ ツリーであるため、ツリーの深さは log(n)+1 でなければならず、最良および最悪の時間計算量は両方とも O(n*log(n)) になります。マージ ソートは、大きな配列を 2 つの小さな配列に分割し、順番に再帰することです。これは、log(n)+1 の深さのバイナリ ツリーと同等であるため、最良の時間計算量と最悪の時間計算量は両方とも O(n*log( n))。順方向または逆方向のクイック ソートの場合、各分割は前の分割よりも 1 レコード少ないサブシーケンスのみを取得します。これは再帰ツリー (この場合は n-1 回の再帰) で描画されます。この除算では、i 番目のレコードを見つけるために n-i 個のキーワード比較が必要であるため、時間計算量は sum_{i=1}^{n-1}(n-i)=n(n-1)/2 となります。 、つまり O(n ^2) です。