Python 算法基础 排序实现

写在前面

随机生成待排序数组

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)