排序算法的执行效率一般可以通过时间复杂度和比较或移动的次数来衡量。
递归算法
递归是一种广泛的算法，如DFS深度优先搜索、前中后序二叉树的遍历。递归满足的条件，将一个问题可以分解为几个问题的解，但这个问题与分解之后的子问题，除了数据规模不同，求解的思路是一样的，还存在递归的终止条件
#问题：
#用递归的方式输出列表中的每一个元素
#li = ['jack',('tom',23),'rose',(14,55,67)]
def fn(n):
if isinstance(n, (int, str)):
print(n)
else:
for item in n:
fn(item)
l = ['jack',('tom',23),'rose',(14,55,67)]
fn(l)
输出
冒泡排序
重复遍历要排序的数列，依次比较两个元素，如果他们顺序错误就把他们交换过来。遍历数列是重复进行直到不在需要交换，完成排序。
比较相邻的元素，如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，最后的元素会是最大的数。
def bubble_sort(li):
for j in range(len(li)-1 ,0 ,-1):
#j 每次遍历需要的次数
for i in range(j):
if li[i]>li[i+1]:
li[i], li[i+1] = li[i+1], li[i]
li = [54,63,45,12,66,98,27,71,73,18]
bubble_sort(li)
print(li)
运行后完成排序
选择排序
一种简单直观的排序算法，首先在排序序列中找到最小或最大的元素，存放到起始的位置，然后在从剩余未排序元素中继续寻找最小或最大元素，然后放到已排序的末尾，直到所有元素排序完成。
选择排序每次交换一对元素，至少有一个将被移到最终的位置，对n个元素的表进行排序总共进行了n-1次交换。
排序算法实现
def select_sort(li):
"""选择排序"""
n = len(li)
for i in range(n-1):
#记录最小位置
min_index = i
for j in range(min_index, n):
if li[j] < li[min_index]:
min_index = j
li[i], li[min_index] = li[min_index], li[i]
li = [17,71,38,83,54,27]
select_sort(li)
print(li)
插入排序
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置插入。在从后向前扫描的过程中，需要反复把已排序元素逐步向后移位，为最新元素提供插入空间。
将数组分为两个区间，已排序区间和未排序区间，初始排序区间只有一个元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序，重复这个过程，直到未排序中元素为空
#插入排序
def insert_sort(li):
#从第二个位置，开始向前插入
for i in range(1, len(li)):
#从第i个元素开始向前比较，如果小于前一个元素，交换位置
for j in range(i, 0, -1):
if li[j] < li[j-1]:
li[j], li[j-1] = li[j-1], li[j]
li = [17,71,38,83,54,27,33,99,44]
insert_sort(li)
print(li)
快速排序
快速排序又可成为划分交换排序，通过一趟排序要将排序的数列分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据要小，然后再按次中方法对这两部分进行快速排序，整个排序过程可以递归进行，达到整个数据变成有序序列。
1.从数列中挑一个元素，为“基准”
2.重新排序数列，所有元素比基准小的摆放再基准的前面，所有比基准大的摆在基准的后面（相同的数可以放在任意的一边），分区结束，该基准就处于数列的中间位置，称为分区操作。
3.递归地把小于基准元素的子数列和大于基准的子数列排序
def quick_sort(alist, start, end):
"""快速排序"""
#递归的退出条件
if start >= end:
return
#设定起始元素要寻找位置的基准条件
mid = alist[start]
#low为序列左边的 由左向右移动的游标
low = start
#high为序列右边的 由由向左的游标
high = end
while low < high:
#如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
while low < high and alist[high] >= mid:
high -= 1
#将high指向的元素放到low的位置上
alist[low] = alist[high]
#如果low与high未重合， low指向的元素比基准元素小，则low向右移动
while low < high and alist[low] < mid:
low += 1
#将low指向的元素放到high的位置上
alist[high] = alist[low]
#退出循环， low 与 high重合， 此时所指位置为基准元素的正确位置
#将基准位置放到该位置
alist[low] = mid
#对基准元素左边的子序列进行快速排序
quick_sort(alist, start, low-1)
#对基准元素右边的子序列进行快速排序
quick_sort(alist, low+1, end)
alist = [17,71,38,83,54,27,33,99,44]
quick_sort(alist, 0, len(alist)-1)
print(alist)
希尔排序
希尔排序是插入排序的一种，也称缩小增量排序，是非稳定排序的算法。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
将数组列在一个列表中并对列分别进行插入排序，重复过程，不过每次用更长的列来进行，最后整个表就只有一列了。
def shell_sort(li):
n = len(li)
#初始步长
gap = n // 2
while gap > 0:
#按步长进行排序
for i in range(gap, n):
#插入排序
while i >=gap and li[i-gap] > li[i]:
li[i - gap],li[i] = li[i], li[i- gap]
i -=gap
#得到新的步长
gap = gap//2
li = [17,71,38,83,54,27,33,99,44]
shell_sort(li)
print(li)
归并排序
归并排序是采用分治法的一个典型的应用，就是先递归分解数组再合并数组。
将数组分解最小之后，然后合并两个有序数组，是比较两个数组最前面的数，谁小就先取谁，取了后相应的指针就往后移一位，再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
def merge_sort(li):
#如果列表长度小于一 ，不在继续拆分
if len(li) <= 1:
return li
#二分分解
mid_index = len(li) // 2
left = merge_sort(li[:mid_index])
right = merge_sort(li[mid_index:])
#合并
return merge(left, right)
def merge(left, right):
"""合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组"""
#left与right的下标指针
l_index, r_index = 0, 0
result = []
while l_index < len(left) and r_index < len(right):
if left[l_index] < right[r_index]:
result.append(left[l_index])
l_index += 1
else:
result.append(right[r_index])
r_index += 1
result += left[l_index:]
result += right[r_index:]
return result
li = [17,71,38,83,54,27,33,99,44]
sorted_alist = merge_sort(li)
print(sorted_alist)
几种排序算法的比较
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
