python实现常用排序算法

冒泡排序

冒泡排序就是一直循环将最大的元素至于列表的最后面，因为要比较i+1，所以外层循环只能循环到len(list)-1

import random

def bubble_sort(list1):
    for i in range(len(list1)-1):
        for j in range(len(list1)-i-1):
            if list1[j] > list1[j+1]:
                list1[j], list1[j+1] = list1[j+1], list1[j]

if __name__ == '__main__':
    list1 = [random.randint(0, 100) for i in range(8)]
    print(list1)
    bubble_sort(list1)
    print(list1)

选择排序

每次选择最大或最小的元素的索引置于队列开头，所以外层循环只能循环到len(list)-1

import random

def select_sort(alist):
    for i in range(len(alist)-1):
        min_index = i
        for j in range(i+1, len(alist)):
            if alist[min_index] > alist[j]:
                min_index = j
        if min_index != i:
            alist[i], alist[min_index] = alist[min_index], alist[i]
    print(alist)
if __name__ == "__main__":
    alist = [ random.randint(0,100) for x in range(0,8)]
    print(alist)
    select_sort(alist)

插入排序

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

import random

def insert_sort(alist):
    for i in range(1, len(alist)):
        for j in range(i, 0, -1):
            print(j)
            if alist[j] < alist[j-1]:
                alist[j], alist[j-1] = alist[j-1], alist[j]
            else:
            	break
    print(alist)

if __name__ == "__main__":
    alist = [random.randint(0, 100) for i in range(8)]
    print(alist)
    insert_sort(alist)

希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

import random

def shell_sot(alist):
    n = len(alist)
    gap = n // 2
    while gap >= 1:
        for i in range(gap, n):
            j = i
            while (j - gap) >= 0:
                if alist[j] < alist[j-gap]:
                    alist[j], alist[j-gap] = alist[j-gap], alist[j]
                    j = j - gap
                else:
                    break
        gap //= 2
    print(alist)

if __name__ == "__main__":
    alist = [random.randint(0, 100) for i in range(8)]
    print(alist)
    shell_sot(alist)

快速排序

import random

def quick_sort(alist,start, end):
    if start >= end:
        return
    mid = alist[start]
    left = start
    right = end
    while left < right:
        while left < right and alist[right] >= mid:
            right -= 1
        alist[left] = alist[right]
        while left < right and alist[left] < mid:
            left += 1
        alist[right] = alist[left]
    alist[left] = mid
    quick_sort(alist, start, left-1)
    quick_sort(alist, left+1, end)

if __name__ == "__main__":
    alist = [random.randint(0, 100) for i in range(8)]
    print(alist)
    quick_sort(alist, 0, len(alist)-1)
    print(alist)

归并排序

import random

def merge_sort(alist):
    n = len(alist)
    if 1 == n:
        return alist
    mid = n // 2
    # 对左半部分进行排序
    lefe_sorted_li = merge_sort(alist[:mid])
    # 对右半部分进行排序
    right_sorted_li = merge_sort(alist[mid:])
    # 进行合并
    left, right = 0, 0
    merge_sort_li = list()
    left_n = len(lefe_sorted_li)
    right_n = len(right_sorted_li)
    while left < left_n and right < right_n:
        if lefe_sorted_li[left] < right_sorted_li[right]:
            merge_sort_li.append(lefe_sorted_li[left])
            left += 1
        else:
            merge_sort_li.append(right_sorted_li[right])
            right += 1
    merge_sort_li += lefe_sorted_li[left:]
    merge_sort_li += right_sorted_li[right:]
    return merge_sort_li

if __name__ == "__main__":
    alist = [random.randint(0, 100) for i in range(8)]
    print(alist)
    print(merge_sort(alist))

复杂度比较