파이썬의 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],

3. 버블 정렬

#-*- 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],

4.

#-*- 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],

5. 퀵 정렬

#-*- coding:utf8 -*-
'''
描述(利用递归，效率较低，较难理解)
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
'''
def quick_sort(lists, left, right):
    if left >= right:
        return lists
    key = lists[left]
    low = left
    high = right
    while left < right:
        while left < right and lists[right] >= key:
            right -= 1
        lists[left] = lists[right]
        while left < right and lists[left] <= key:
            left += 1
        lists[right] = lists[left]
    lists[right] = key
    quick_sort(lists, low, left - 1)
    quick_sort(lists, left + 1, high)
    return lists

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

6. 힙 정렬

#-*- coding:utf8 -*-
'''
描述(较难理解)
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。
堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。
在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
'''
# 调整堆
def adjust_heap(lists, i, size):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    max = i
    if i < size / 2:
        if lchild < size and lists[lchild] > lists[max]:
            max = lchild
        if rchild < size and lists[rchild] > lists[max]:
            max = rchild
        if max != i:
            lists[max], lists[i] = lists[i], lists[max]
            adjust_heap(lists, max, size)

# 创建堆
def build_heap(lists, size):
    for i in range(0, (size/2))[::-1]:
        adjust_heap(lists, i, size)

# 堆排序
def heap_sort(lists):
    size = len(lists)
    build_heap(lists, size)
    for i in range(0, size)[::-1]:
        lists[0], lists[i] = lists[i], lists[0]
        adjust_heap(lists, 0, i)

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

7. 병합 정렬

#-*- coding:utf8 -*-
'''
描述（利用递归）
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，
并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，
先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
'''
def merge(left, right):
    #合并过程
    i, j = 0, 0
    result = []
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

def merge_sort(lists):
    if len(lists) <= 1:
        return lists
    mid = len(lists) / 2
    left = merge_sort(lists[:mid])
    right = merge_sort(lists[mid:])
    return merge(left, right)

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

8. 🎜>

다음은 다양한 정렬 알고리즘의 시간 복잡도와 안정성 비교입니다.

#-*- coding:utf8 -*-
'''
描述（表示没接触过，第一次听说）
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，
将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，
其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
'''
import math
def radix_sort(lists, radix=10):
    k = int(math.ceil(math.log(max(lists), radix)))
    bucket = [[] for i in range(radix)]
    for i in range(1, k+1):
        for j in lists:
            bucket[j/(radix**(i-1)) % (radix**i)].append(j)
        del lists[:]
        for z in bucket:
            lists += z
            del z[:]
    return lists

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

평균 속도가 가장 빠른 정렬 알고리즘은 무엇인가요?

정렬 방법 평균 사례 최선 사례 최악 사례 보조 공간 안정성

버블 정렬 O(n^2) O(n) O(n^2)​ ​ 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))입니다. 병합 정렬은 큰 배열을 두 개의 작은 배열로 나누고 순서대로 반복하는 것으로, 깊이가 log(n)+1인 이진 트리와 동일하므로 최고 및 최악의 시간 복잡도는 모두 O(n*log( N)). 정방향 또는 역방향 빠른 정렬의 경우 각 분할은 이전 분할보다 하나 적은 레코드만 얻습니다. 이는 편향 트리인 재귀 트리를 사용하여 그려집니다. 이 구분에서는 i번째 레코드를 찾기 위해 n-i 키워드 비교가 필요하므로 시간 복잡도는 sum_{i=1}^{n-1}(n-i)=n(n-1)/2입니다. , 즉 O(n ^2)입니다.