7种排序算法的Python实现

使序列成为一个按关键字有序的序列

稳定性：排序前 ki=kj(1<=i,j<=n,i!=j) && i<j
排序后 如果 i<j 排序方法稳定; 如果 i>j 排序方法不稳定

内排序：待排序的所有记录全部被放置在内存中。
外排序：整个排序过程需要在内外存之间多次交换数据。

"""直接插入排序

思想
将一个记录插入到有序的序列中

时间复杂度
平均 o(n^2)

最好 o(n),    比较n-1次
最坏 o(n^2),  比较2+3+...+n次，交换3+4+...+n+1次
"""

array = [44, 32, 24, 23, 21, 18, 15, 10, 4, 2]
length = len(array)

def straight_insertion_sort():
for i in range(2, length):
if array[i] < array[i-1]:
temp = array[i]  # 设置哨兵
j = i-1
while temp < array[j] and j >= 0:
array[j], array[j+1] = array[j+1], array[j]
j -= 1

array[j+1] = temp

straight_insertion_sort()
print(array)

"""希尔排序

插入排序的改进版

思想
将相聚某个“增量”（increment）的记录组成一个子序列，各子序列分别进行插入排序以使子序列基本有序。

基本有序：小的关键字基本在前，大的关键字基本在后，不大不小的关键字基本在中间。

增量序列的最后一个增量值必须为1，增量公式int(increment / 3 + 1)。

时间复杂度

"""

array = [44, 32, 24, 23, 21, 18, 15, 10, 4, 2]
length = len(array)

def shell_sort():
increment = length

while increment > 1:
increment = int(increment / 3 + 1)  # 增量公式

for i in range(increment, length, increment):
if array[i] < array[i-increment]:
temp = array[i]
j = i - increment
while temp < array[j] and j >= 0:
array[j], array[j + increment] = array[j + increment], array[j]
j -= increment

array[j + increment] = temp

shell_sort()
print(array)

"""简单选择排序

思想
通过n-i次关键字比较，在n-i+1个元素中选出关键字最小(大)的记录，并和第i个记录交换。

时间复杂度
平均 o(n^2)

最好 o(n^2)，比较n-1次
最坏 o(n^2)，比较n-1+n-2+...+1=n(n-1)/2次,交换n-1次

"""

array = [44, 32, 24, 23, 21, 18, 15, 10, 4, 2]
length = len(array)

def simple_selection_sort():
for i in range(0, length-1):
min = i

for j in range(i+1, length):
if array[min] > array[j]:
min = j

if min is not i:
array[min], array[i] = array[i], array[min]

simple_selection_sort()
print(array)

"""堆排序

思想
1.将待排序序列构建成一个大(小)顶堆，此时整个序列的最大(小)值就是堆顶的根节点。
2.将大(小)顶堆根节点与堆数组的末尾元素交换
3.然后将除末尾以外的元素重新构造成一个大(小)顶堆
4.如果堆的节点个数大于1，回到2

堆是一个完全二叉树
大顶堆：每个节点的值都大于或等于其左右孩子节点的值
小顶堆：每个节点的值都小于或等于其左右孩子节点的值

"""

# 注意：这是完全二叉树，为方便运算(堆第i个节点的左孩子节点和右孩子节点位置分别是2i, 2i+1,),第一个元素一定要放在下标为1的位置
array = [0, 50, 10, 90, 30, 70, 40, 80, 60, 20]
length = len(array)-1

def heap_sort():
# 构建堆
for i in range(int(length/2), 0, -1):
adjust(i, length)

# 调整剩余元素为一个新的堆
for i in range(length, 1, -1):
array[1], array[i] = array[i], array[1]
adjust(1, i-1)

def adjust(p, length):
temp = array[p]
i = 2*p
while i <= length:
if i+1 <= length and array[i] < array[i+1]:
i += 1
if temp > array[i]:
break

array[p] = array[i]

p = i
i *= 2

array[p] = temp

heap_sort()
print(array)

"""冒泡排序

思想
两两比较相邻记录

时间复杂度
平均 o(n^2)

最好 o(n)     本身有序，比较n-1次
最坏 o(n^2)   本身逆序，比较1+2+3+...+(n-1)=n(n-1)/2次,交换1+2+3+...+(n-1)=n(n-1)/2次

"""

array = [44, 32, 24, 23, 21, 18, 15, 10, 4, 2]
length = len(array)

def bubble_sort_1():
"""
从后往前比较
"""
i = 0
while i < length-1:
j = length-2
while j >= i:
if array[j] > array[j+1]:
array[j], array[j + 1] = array[j + 1], array[j]  # python中交换简写

j -= 1

i += 1

def bubble_sort_2():
"""
从前往后比较
"""
i = 0
while i < length-1:
j = 0
while j < length-1-i:
if array[j] > array[j+1]:
array[j], array[j + 1] = array[j + 1], array[j]  # python中交换简写

j += 1

i += 1

def bubble_sort_improved():
"""冒泡排序改进版

当序列近似顺序时，避免不必要的比较，提高效率
"""
i = 0
flag = True
while i < length-1 and flag:  # 当flag为False，退出循环
flag = False

j = length-2
while j >= i:
if array[j] > array[j+1]:
array[j], array![j+1] = array[j+1],array[j]
flag = True

j -= 1

i += 1

bubble_sort_2()
print(array)

"""快速排序

思想
1.选取序列中一个元素作为枢轴，让其左边的值都比它小，右边的值都比它大。
2.将序列以枢轴为界限分割为左右两部分序列，如果分割后的序列的元素个数大于1，则执行步骤1。

"""
array = [32, 50, 10, 30, 30, 70, 40, 80, 60, 20]
length = len(array)

def quick_sort(f, r):
if f >= r:
return

i = f
j = r

temp = array[f]
while f < r:
while f < r and temp <= array[r]:  # 从后向前比较
r -= 1

if f < r:
array[f] = array[r]

while f < r and temp >= array[f]:  # 从前向后比较
f += 1

if f < r:
array[r] = array[f]

array[r] = temp  # 此时r和j重合

quick_sort(i, f-1)
quick_sort(f+1, j)

quick_sort(0, 9)
print(array)

"""归并排序

思想
序列含有n个记录，可以看成n个有序子序列，每个子序列的长度为1，然后两两归并。

"""

array = [32, 50, 10, 30, 30, 70, 40, 80, 60, 20]
length = len(array)

def merging_sort(f, r):
if f >= r:
return

mid = int((f+r)/2)

merging_sort(f, mid)
merging_sort(mid+1, r)
merge(f, mid, r)

def merge(f, mid, r):
temp = []
i = f
j = mid+1

while i <= mid and j <= r:
if array[i] <= array[j]:
temp.append(array[i])
i += 1
else:
temp.append(array[j])
j += 1

while i <= mid:
temp.append(array[i])
i += 1
while j <= r:
temp.append(array[j])
j += 1

for k in range (0, len(temp)):
array[f+k] = temp[k]

merging_sort(0, 9)
print(array)