Python 算法基础 排序实现

写在前面

重新学习Python，打算从最基本的排序算法开始实现。
这些算法的理论和知识在网上一搜都是大把大把的，因此这里不写理论知识，直接放代码。
冒泡排序、直接插入排序、希尔排序、计数排序、堆排序、归并排序、快速排序均基于Python3实现。

随机生成待排序数组

import random

def generateRandomData(num):
    # num表示带排序数组中数的个数，返回的ans是一个list。
    ans = []
    i = 0
    while i<num:
        ans.append(random.randint(0, 10000))
        i+=1
    return ans

data = generateRandomData(7)
print('randomData:',data)

1 冒泡排序

def bubbleSort(data):
    '''
    data为待排序的list
    时间复杂度为n^2
    '''
    l = len(data)
    for i in range(1, l):
        for j in range(i, l)[::-1]:
            if data[j-1] > data[j]:
                data[j], data[j-1] = data[j-1], data[j]
    return data

bubbleSort(data)
print(data)

2 直接插入排序

def insertSort(data):
    '''
    时间复杂度为n^2
    '''
    l = len(data)
    for i in range(1, l):
        tmp = data[i]
        while i>0:
            if tmp >= data[i-1]:
                break
            data[i] = data[i-1]
            i -= 1
        data[i] = tmp
    return data

insertSort(data)
print(data)

3 希尔排序

def shellSort(data):
    '''
    时间复杂度为n^(3/2)
    最后一次排序的增量需要为1
    '''
    l = len(data)
    step = l // 2
    while step > 0 :
        for i in range(0, step):
            '''
            每个step里每个组，采用直接插入排序
            '''
            j = i + step
            while j < l:
                k = j - step
                tmp = data[j]
                while k >= 0:
                    if tmp >= data[k]:
                        break
                    data[k+step] = data[k]
                    k -= step
                data[k+step] = tmp
                j = j + step
        step = step // 2

shellSort(data)
print(data)

4 计数排序

def countSort(data, l):
    '''
    时间复杂度为n
    l为待排序数组中可能的最大值
    需要额外空间
    '''
    l = l + 1
    data_count = [0 for x in range(l)]
    data_ans = [0 for x in range(len(data))]
    for x in data:
        data_count[x] = data_count[x] + 1
    for i in range(1, l):
        data_count[i] = data_count[i] + data_count[i-1]
    for x in data:
        data_ans[data_count[x]-1] = x
        data_count[x] -= 1
        # print(data_ans)
    return data_ans

print(countSort(data, 10000))

5 堆排序

def heapAdjust(dlist, p, r):
    '''
    调整堆为大顶堆
    '''
    tempdata = dlist[p]
    j = 2*p
    while j <= r:
        if j < r and dlist[j] < dlist[j+1]:
            j += 1
        if tempdata > dlist[j]:
            break
        dlist[p] = dlist[j]
        p = j
        j = 2 * p
    dlist[p] = tempdata

def heapSort(data):
    '''
    1 无序堆改变为大顶堆
    2 抽出最小的元素后 重新排成大顶堆
    时间复杂度为nlgn
    '''
    l = len(data)
    data.insert(0, 0)
    for i in range(l//2, 0, -1):
        heapAdjust(data, i, l)
    for i in range(l, 0, -1):
        data[1], data[i] = data[i], data[1]
        heapAdjust(data, 1, i-1)
    data.pop(0)
    return data

heapSort(data)
print(data)

6 归并排序

def merge(dlist1, p, q, r):
    '''
    merge the dlist1[p, q] and dlist2[q+1, r]
    output dlist as the results of merge
    this function use the additional memory
    '''
    l = len(dlist1)
    sublist1 = dlist1[p: q+1]
    sublist2 = dlist1[q+1: r+1]
    sublist1.append(float('inf'))
    sublist2.append(float('inf'))
    p1 = 0
    p2 = 0
    for i in range(p, r+1):
        if sublist1[p1] <= sublist2[p2]:
            dlist1[i] = sublist1[p1]
            p1 += 1
        else:
            dlist1[i] = sublist2[p2]
            p2 += 1
    del sublist1
    del sublist2
    return dlist1

def msort(dlist, p, r):
    if p == r:
        return dlist
    else:
        q = (p + r)//2
        msort(dlist, p, q)
        msort(dlist, q+1, r)
        merge(dlist, p, q, r)

def mergeSort(data):
    '''
    时间复杂度为n+lgn
    '''
    l = len(data)
    msort(data, 0, l-1)
    return data

mergeSort(data)
print(data)

7 快速排序

def quickSortPartition(dlist, p, r):
    i = p - 1
    for j in range(p, r):
        if dlist[j] >= dlist[r]:
            continue
        else:
            i += 1
            dlist[i], dlist[j] = dlist[j], dlist[i]
    dlist[i+1], dlist[r] = dlist[r], dlist[i+1]
    return i+1

def qsort(dlist, p, r):
    if p < r :
        q = quickSortPartition(dlist, p, r)
        qsort(dlist, p, q-1)
        qsort(dlist, q+1, r)

def quickSort(data):
    '''
    平均时间复杂度为nlgn
    最坏时间复杂度为n^2
    平均空间复杂度为lgn
    '''
    l = len(data)
    qsort(data, 0, l-1)
    return data

quickSort(data)
print(data)