各种排序复杂度、稳定度对比：
class DiversitySort(object):
# def __init__(self, arr):
# pass
# self.arr = arr
def generateRandomArr(self, maxLen, maxValue):
"""
返回一个数组arr，arr长度[0,maxLen-1],arr中的每个值[0,maxValue-1]
:return:
"""
len = int(random.random() * maxLen)
arr = [0] * len
for i in range(len):
arr[i] = int(random.random() * maxValue)
return arr
def heapify(self, arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
self.heapify(arr, n, largest)
def heapSort(self, arr):
"""
堆排序
时间复杂度：
空间复杂度：
:param arr:
:return:
"""
n = len(arr)
# Build a MaxHeap
for i in range(n, -1, -1):
self.heapify(arr, n, i)
print(arr)
# 一个个交换元素
for i in range(n - 1, 0, -1):
# Swap item
arr[i], arr[0] = arr[0], arr[i]
self.heapify(arr, i, 0)
def selectSort(self, arr):
"""
选择最小的 往前排
:param arr:
:return:
"""
if not arr or len(arr) < 2:
return arr
for i in range(len(arr) - 1):
minIndex = i
for j in range(i, len(arr)):
if arr[j] < arr[minIndex]:
minIndex = j
arr[minIndex], arr[i] = arr[i], arr[minIndex]
return arr
def bubbleSort(self, arr):
"""
两两比较，往后放
:param arr:
:return:
"""
if not arr or len(arr) < 2:
return arr
for i in range(len(arr) - 1, -1, -1):
for j in range(0, i):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
def insertSort(self, arr):
"""
类似于玩扑克，抓到一张新牌，然后插入到序列中
"""
if not arr or len(arr) < 2:
return arr
for i in range(1, len(arr)):
newNumIndex = i
while newNumIndex - 1 >= 0 and arr[newNumIndex - 1] > arr[newNumIndex]:
arr[newNumIndex], arr[newNumIndex - 1] = arr[newNumIndex - 1], arr[newNumIndex]
newNumIndex -= 1
return arr
def merge(self, arr, L, M, R):
"""
对两个有序数组归并
:param arr:
:param L:
:param M:
:param R:
:return:
"""
# 辅助数组
help = [None] * (R-L+1)
i = 0
# 左右两个数组的起始指针位置
p1, p2 = L, M+1
while p1 <= M and p2 <= R:
if arr[p1] <= arr[p2]:
help[i] = arr[p1]
p1 += 1
else:
help[i] = arr[p2]
p2 += 1
i += 1
# p2 越界了
while p1 <= M:
help[i] = arr[p1]
i += 1
p1 += 1
# p1 越界了
while p2 <= R:
help[i] = arr[p2]
i += 1
p2 += 1
# 将help数组拷贝回主数组中
for i in range(len(help)):
arr[L+i] = help[i]
def mergeSort(self, arr):
"""
归并排序，递归方法实现
:param arr:
:return:
"""
def process(arr, L, R):
if L == R:
return
mid = L + int((R - L) >> 1)
process(arr, L, mid)
process(arr, mid+1, R)
self.merge(arr, L, mid, R)
if not arr or len(arr) < 2:
return
process(arr, 0, len(arr) - 1)
def mergeSort2(self, arr):
"""
归并排序，非递归方法实现
:param arr:
:return:
"""
if not arr or len(arr) < 2:
return
step = 1
N = len(arr)
while step < N:
L = 0
while L < N:
# M = 0
if N - L >= step:
M = L + step - 1
else:
M = N - 1
if M == N - 1:
break
# R = 0
if N - 1 - M >= step:
R = M + step
else:
R = N - 1
self.merge(arr, L, M, R)
if R == N - 1:
break
else:
L = R + 1
if step > N/2:
break
step *= 2
