十大经典排序算法(动图演示):这个链接里动图不错,不过是JS实现
1. 交换排序 -- 冒泡排序
# BubbleSort
def main(data):
high = len(data) - 1
low = 0
while low < high:
if data[low] > data[low + 1]:
data[low], data[low + 1] = data[low + 1], data[low]
low += 1
if low == high:
high -= 1
low = 0
2. 交换排序 -- 快排
def base_sort(data, low, high):
half = data[low]
while low < high:
while data[high] >= half and low < high:
high -= 1
data[low] = data[high]
while data[low] <= half and low < high:
low += 1
data[high] = data[low]
data[low] = half
return low
def main(data, low=None, high=None):
if low is None:
low = 0
high = len(data) - 1
if low > high:
return
# 先序
half_index = base_sort(data, low, high)
main(data, low, half_index - 1)
main(data, half_index + 1, high)
3. 插入排序 -- 简单插入排序
def main(data):
end = 0
start = 1
while start < len(data):
while data[end] > data[start] and end >= 0:
end -= 1
data.insert(end + 1, data.pop(start))
start += 1
end = start - 1
4. 插入排序 -- 希尔排序
def main(data):
gap = len(data) // 2
while gap >= 1:
end = 0
while end + gap < len(data):
start = end + gap
while start < len(data):
while data[end] > data[start] and end >= 0:
end -= gap
data.insert(end + 1, data.pop(start))
end = start
start += gap
end += 1
gap = gap // 2
5. 选择排序 -- 简单选择排序
def main(data):
low = 0
high = len(data) - 1
max_index = high
while low < high:
if data[low] > data[max_index]:
max_index = low
low += 1
if low == high:
if max_index != high:
data[max_index], data[high] = data[high], data[max_index]
high -= 1
max_index = high
low = 0
6. 选择排序 -- 堆排序
def modify(data, i, max_index):
left = i * 2
right = left + 1
down = 0
if right <= max_index:
if data[i - 1] >= max(data[left - 1], data[right - 1]):
return
if data[left - 1] > data[right - 1]:
data[i - 1], data[left - 1] = data[left - 1], data[i - 1]
down = left
else:
data[i - 1], data[right - 1] = data[right - 1], data[i - 1]
down = right
elif left <= max_index:
if data[i - 1] < data[left - 1]:
data[i - 1], data[left - 1] = data[left - 1], data[i - 1]
down = left
if down != 0:
modify(data, down, max_index)
def mk_heap(data, max_index):
current_i = max_index // 2
while current_i > 0:
modify(data, current_i, max_index)
current_i -= 1
def main(data):
max_index = len(data)
mk_heap(data, max_index)
while max_index > 0:
data[0], data[max_index - 1] = data[max_index - 1], data[0]
max_index -= 1
modify(data, 1, max_index)
7. 归并排序 -- 二路归并排序
def base_sort(data, l1, r1, l2, r2):
tmp_list = []
tmp_l1 = l1
while l1 <= r1 and l2 <= r2:
if data[l1] < data[l2]:
tmp_list.append(data[l1])
l1 += 1
else:
tmp_list.append(data[l2])
l2 += 1
if l1 <= r1:
tmp_list += data[l1:r1 + 1]
if l2 <= r2:
tmp_list += data[l2:r2 + 1]
data[tmp_l1:r2 + 1] = tmp_list
def main(data, l1=None, r2=None):
if l1 is None:
l1 = 0
r2 = len(data) - 1
if r2 - l1 < 1:
return
half = (r2 - l1) // 2
r1 = l1 + half
l2 = r1 + 1
# 后序
main(data, l1, r1)
main(data, l2, r2)
base_sort(data, l1, r1, l2, r2)
8. 非比较排序 -- 计数排序
def main(data):
min_value, max_value = min(data), max(data)
tmp_list = [0] * (max_value - min_value + 1)
for i in data:
tmp_list[i - min_value] += 1
index = 0
for i, count in enumerate(tmp_list):
while count > 0:
data[index] = i + min_value
count -= 1
index += 1
9. 非比较排序 -- 基数排序
def get_d(i, n):
s = str(i)
if n > len(s):
return 0
return int(s[len(s) - n])
def main(data, max_n=4):
buckets = [[], [], [], [], [], [], [], [], [], []]
for n in range(1, max_n + 1):
for i in data:
buckets[get_d(i, n)].append(i)
index = 0
for bucket in buckets:
while len(bucket) != 0:
data[index] = bucket.pop(0)
index += 1