python 实现常见排序算法

#coding:utf-8

#Bubble sort (冒泡排序)，时间复杂度最坏为O(n2)，最优的为n
import time


def bubble_sort(alist):
    '''
    冒泡排序
    :param alist:
    :return:
    '''
    cur = 1
    while cur != len(alist)-1 and len(alist) != 1:
        for i in range(len(alist)-cur):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
        cur += 1
    print(alist)


def bubble_sort2(alist):
    for j in range(len(alist)-1):
        for i in range(len(alist)-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
    print(alist)
    if __name__ == "__main__":
        alist = [1,2,9,6,35,77,7,8]
        alist1 = [2]
        bubble_sort2(alist1)

##select sort 选择排序 ,时间复杂最优n^2,最坏也为n^2

def select_sort(alist):
    for j in range(len(alist)-1):
        min_index = j
        for i in range(1+j,len(alist)):
            if alist[min_index] > alist[i]:
                min_index = i
        alist[min_index],alist[j] = alist[j],alist[min_index]
    return alist


if __name__ == "__main__":
    alist = [3,4,5,8,1,0,23]
    # print(select_sort(alist))
    #


##插入排序
def insert_sort(alist):
    for j in range(1,len(alist)):
        i = j
        while i>0:
            if alist[i]>alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    return alist


if __name__ == "__main__":
    alist = [3,4,5,8,1,0,23]
    # print(insert_sort(alist))

##希尔排序 ， 插入排序的优化
def shell_sort(alist):
    n = len(alist)
    gap = n//2
    for i in range(gap,len(alist)):
        j = i
        for k in range(i,0,-gap):
            if alist[k] < alist[k-gap]:
                alist[k], alist[k-gap] = alist[k-gap], alist[k]
    print(alist)


if __name__ == "__main__":
    alist = [3,4,5,8,1,0,23]
    # shell_sort(alist)

##快速排序,时间复杂度,最优的时间复杂度为O(logn)，最坏时间复杂度为O(n^2)

def quick_sort(alist,first,last):
    if first < last:
        start = first
        end = last
        base = alist[start]
        while start <end:
            while start != end and (base<=alist[end]):
                end -= 1
            alist[start] = alist[end]
            while start != end and (base>=alist[start]):
                start += 1
            alist[end] = alist[start]
        alist[start] = base

        quick_sort(alist,first,start-1)
        quick_sort(alist,start+1,last)
    return alist


if __name__ == "__main__":
    alist = [3,4,5,8,1,0,0,23]
    # print("result:"+str(quick_sort(alist,0,len(alist)-1)))

#归并算法，时间复杂度nlogn,此算法返回的是一个新列表
def merge_sort(alist):
    """
    归并算法的基本实现
    :param alist:列表
    :return:排序后的列表
    """
    lens = len(alist)
    if lens <= 1:
        return alist
    mid = lens//2

    #left 采用归并排序
    left = merge_sort(alist[:mid])
    right = merge_sort(alist[mid:])
    left_pointer, right_pointer = 0, 0
    result = []
    while left_pointer < len(left) and right_pointer < len(right):
        if left[left_pointer] < right[right_pointer]:
            result.append(left[left_pointer])
            left_pointer += 1
        else:
            result.append(right[right_pointer])
            right_pointer += 1
    result += left[left_pointer:]
    result += right[right_pointer:]
    return result


if __name__ == "__main__":
    alist = [3, 4, 5, 8, 1, 0, 23]
    print(__name__)
    print(merge_sort(alist))