版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
摘要
- 共实现6种排序算法。
- 每个排序算法在代码片种都有核心思想的解释。
- 关于递归在本文最后有所补充。
代码:
冒泡排序:找到最大的,然后放最后。每一次循环都可能伴随着一次交换。
def bubble_sort(alist):
'''冒泡排序'''
n = len(alist)
# 直接用n也可以
for j in range(n-1): # 控制每一次循环都能找到一个最大的。一直到倒数第二小和倒数第一小进行比较。
count = 0 # 改进之后最优时间复杂度由n^2变为n
for i in range(n-1-j): # 每一次循环找到一个最大的放最后
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]
count += 1
if count == 0:
return
if __name__ == '__main__':
li = [12,53,2,200, 5,101, 89, 98, 100]
# li = [12]
bubble_sort(li)
print(li)
# 当相等时,不会交换位置,所以它是稳定的。
选择排序:选一个最小的放最开始,循环结束确定最小的。
def select_sort(alist):
'''选择排序'''
n=len(alist)
for j in range(n-1): # 默认第一个是最小的索引
min_num = j
for i in range(1+j, n): # 取出真正的最小的索引
if alist[min_num] > alist[i]:
min_num = i
alist[j], alist[min_num] = alist[min_num], alist[j] # 交换位置
# 当两数相等时,排序之后不会影响其原本所在的位置,即为稳定。
# 当以寻找最大数放置-1索引位置时,该函数是不稳定的。
alist = [17,20,93,54,77,31,44,55,226]
select_sort(alist)
print(alist)
插入排序:一直与前一个比较,比较之后再与前前一个比较,将每次比较出来的放置合适的位置。
# coding:utf-8
alist = [17,20,93,54,77,31,44,55,226]
def insert_sort(alist):
'''插入排序'''
n = len(alist)
for j in range(n-1): # 操作多少个数,代表多少次
i = j+1 # i 代表从哪个数开始操作(索引)
while i > 0: # range(j,0,-1)
if alist[i]<alist[i-1]:
alist[i],alist[i-1] = alist[i-1],alist[i]
i -= 1
# else 对程序本身没有影响,这是一个性能优化---o(n)2到o(n)(如果去掉else,需要把 i-=1(shift tab))
else:
break
insert_sort(alist)
print(alist)
# 稳定性:稳定。相同的元素的时候是不会进行交换操作的,所以稳定。
借助插入排序原理,但是比较的值不再是相邻的,而是按照一定的步长去比较。
# coding utf-8
alist = [17,20,93,54,77,31,44,55,226]
def shell_sort(alist):
'''希尔排序'''
n = len(alist)
gap = n//2 # gap取中间值(其实它是不固定的,需要根据数学来计算?)
while gap > 0: # 将gap的值不断的缩小,当gap==1的时候,实际上便是利用插入排序操作了整个序列
# 内层循环达到的效果是:每个以gap步长为基准的“子序列”是有序的,并不能代表整个序列是有序的。
for j in range(gap, n): # 一个循环处理了“子序列”的以gap为步长的元素质之间的比较。
i = j
while i > 0:
if alist[i] < alist[i-gap]:
alist[i], alist[i-gap] = alist[i-gap], alist[i]
i -= gap
else:
break
# 缩短gap步长
gap //= 2
shell_sort(alist)
print(alist)
# 时间复杂度: 假设gap取1,那么就是一个很普通的插入排序,最坏时间复杂度是o(n^2);最优时间复杂度需要根据gap的值来确定。
# 稳定:因为分成几部分对待,所以相同的数可能不在一个“子序列”,于是不稳定。
快速排序:所有比他大的都在他的右边,所有比他小的都在他的左边(默认第一个值为中间值)。
# coding:utf-8
def quick_sort(alist,first,last):
'''快速排序'''
# 递归终止条件
if first >= last: # 为什么是>号,而不是==号? 因为递归传参的时候可能存在传递的first和low-1中的low已经相等了,这个时候first是>low-1的,而这时候first和low-1作为索引对应的值在列表中还是可以找到的,所以仍会递归,于是出现递归错误。(这里判断条件有无=都可以)
return
# 规定第一个值为中间值
mid_value = alist[first]
low = first
high = last
while low < high:
# 条件成立,height左移,循环不成立将小于中间值的放置左边
while low < high and alist[high] >= mid_value: # 等号存在的意义是将相等的数值放置右边(这是快速排序的思想决定的)。
# 另外条件low<height是不可以去掉的,假设alist[high] >= mid_value一直满足,high就会一直变小,直到已经等于low,甚至小于low的时候还没有退出循环,就会超出索引的情况了。(在第一层循环满足的情况下,第二层循环在没退出的情况下是不受第一层循环限制的)。
high -= 1
alist[low] = alist[high]
# 当退出上层循环的时候alist[height]的位置空着,所以我们判断左边的
# 条件成立,low右移,循环不成立将大于中间值的放置右边
while low < high and alist[low] < mid_value: # 由于上一个同级别循环的限制,形成了即使low无限的+1,也一定会存在alist[low] == mid_value,即退出循环,所以这一个循环的判断条件,有无low < high都可以。
low += 1
alist[high] = alist[low]
# 循环退出时 low==height
alist[low] = mid_value
# 递归
# 对low左边列表执行快速排序(low是中间值,当然这个low也可以是high,因为中间值的时候就是alist[low]==alist[high]的时候)
quick_sort(alist,first,low-1)
# 对low右边列表执行快速排序
quick_sort(alist,low+1,last)
if __name__ == '__main__':
alist = [17, 20, 93, 54, 77, 31, 44, 55, 226]
quick_sort(alist,0,len(alist)-1)
print(alist)
# 最优时间复杂度是Nlogn.(logn是因为把n等分多少次而得的)n是每次拆分需要进行n次比较。
# 最坏时间复杂度是n2 第一个n是因为需要对每个元素操作 第二个n是因为每次对其中的一个元素操作的时候还要对n-1个元素操作。所以n*(n-1)约等于n^2
# 不稳定(参考二层循环中的第一个循环)
归并排序:先把数列拆开(拆到不能再拆了),然后依次往上按照升序来合并。
# coding:utf-8
def merge_sort(alist):
'''归并排序'''
n = len(alist)
if n <= 1: # 递归退出条件
return alist # 这个返回值是由最后一次调用递归的那个函数接受的(拆分到不能拆分了就返回了),也就是被left_li或者right_li接受了。这时并不会终止程序,只会终止此次递归,而后这次递归返回的数据也就是(left_li和right__li)都会进行下面的循环代码,之后返回值result_list便是可进行下面循环代码的递归函数来接受的,还是用(left_li或者right_li来接受),然后反复进行下面的循环,直到第一次调用这个函数得到了属于自己的返回值,代码运行结束。
mid = n//2
# 接受归并排序后左边的有序列表
left_li = merge_sort(alist[:mid])
# 接受归并排序后右边的有序列表
right_li = merge_sort(alist[mid:])
left_pointer, right_pointer = 0, 0
result_list = []
# 循环条件满足时,说明左右两边的游标都没有走到列表的末尾
while left_pointer < len(left_li) and right_pointer < len(right_li):
if left_li[left_pointer] <= right_li[right_pointer]: # =号 是使排序稳定的作用
result_list.append(left_li[left_pointer])
left_pointer += 1
else:
result_list.append(right_li[right_pointer])
right_pointer += 1
# 退出循环后,让result_list需要和最后剩下的那个列表中的所有的元素都需要合并
result_list += left_li[left_pointer:]
result_list += right_li[right_pointer:]
return result_list
if __name__ == '__main__':
li = [17, 20, 93, 54, 77, 31, 44, 55, 226]
print(merge_sort(li))
# 时间复杂度:nlogn n每次合并的最大次数,logn为拆分的总次数。由于必须从中间拆分(没有特殊情况):所以最优最差时间复杂度都是nlogn
# 稳定:因为合并的时候并没有改变相同元素的排列位置。
# 拓展: 时间最短,但是它要新建一个列表,所以在空间上是有额外的开销的。
# 归并排序和快速排序的区别:
# 后者是在列表本身上操作,前者需要新建列表来接受“确定值”。
# 后者理念是:将大的放“某一个数”右边,小的放左边,然后再以“某一个数”为分界点拆开,拆开后还按照“大的在右,小的在左”的思想去操作。前者的理念是:全都拆开,然后一点点的比较,然后放置新的列表中并返回。
补充:如何更好的理解递归?
- 1,递归需要终止条件
- 2,递归一般处理需要多次进行相同的操作。
- 3,递归一般需要返回值,如果没有返回值,它肯定也“改变”了什么。
- 本文仅服务作者本人。