一. 冒泡排序
-
对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
-
针对所有的元素重复以上的步骤,除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
代码实现:
def bubble_sort(li):
for i in range(len(li)-1):#第i趟
for j in range(len(li)-i-1):
if li[j]>li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
改进版:
判断第i趟结束后有没有发生位置交换,如果没有,表示数组已经排好序,不再需要进行下一趟。
def bubble_sort1(li):
for i in range(len(li)-1):
change = 0
for j in range(len(li)-i-1):
if li[j]>li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
change = 1
if not change:
return
二. 选择排序
首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
def select_sort(li):
for i in range(len(li)): #i是第几趟
min_loc = i
for j in range(i+1,len(li)):
if li[j]<li[min_loc]:
min_loc = j #找到当前无序区最小值下标
if min_loc!=i:
li[min_loc], li[i] = li[i], li[min_loc]
三. 插入排序
插入排序是指在待排序的元素中,假设前面n-1(其中n>=2)个数已经是排好顺序的,现将第n个数插到前面已经排好的序列中,然后找到合适自己的位置,使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入,直到整个序列排为有序的过程,称为插入排序。
def insert_sort(li):
for i in range(1,len(li)): #i是摸到的牌的下标
j = i-1 #j是手里最后一张牌的下标
tem = li[i]
while j>=0 and li[j]>tem: #找插入位置
li[j+1] = li[j]
j -= 1
li[j+1] = tem
四. 快速排序
取一个元素p(第一个元素),使元素p归位,列表被元素p分为两部分,左边都比p小,右边都比p大。递归完成排序
def partition(li, left, right): #归位函数
tem = li[left]
while left<right:
while left<right and li[right]>tem: #从右边找比tem小的数
right -= 1 #往左走一步
li[left] = li[right] #把右边的值填到左边的空位
while left<right and li[left]<tem: #从左边找比tem大的数
left += 1
li[right] = li[left]
li[left] = tem #把tem归位
return left
def quick_sort(li, left, right):
if left<right: #至少两个元素
mid = partition(li, left, right)
quick_sort(li, left, mid-1)
quick_sort(li, mid+1, right)
五. 堆排序
堆排序的基本思想是:将待排序序列构造成一个大顶堆,此时,整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换,此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆,这样会得到n个元素的次小值。如此反复执行,便能得到一个有序序列了。
def sift(li, low, high):
i = low
j = 2*i+1
tmp = li[low] #存堆顶元素
while j<=high: #只要j位置有数
if j+1<=high and li[j+1]>li[j]: #取孩子节点种大的数
j = j+1
if li[j]>tmp:
li[i] = li[j]
i = j # 往下看一层
j = 2*i+1
else: #tmp更大,把tmp放到i位置
break
li[i] = tmp #把tmp放到叶子节点
def heap_sort(li):
n = len(li)
for i in range(n//2-1, -1, -1):#i表示建堆的时候调整部分的根的下标
sift(li, i, n-1)
#建堆完成
for i in range(n-1, -1, -1):#i指向当前堆的最后一个元素
li[0], li[i] = li[i], li[0]
sift(li, 0, i-1)#i-1是新的high
六. 归并排序
归并排序是用分治思想,分治模式在每一层递归上有三个步骤:
- 分解(Divide):将n个元素分成个含n/2个元素的子序列。
- 解决(Conquer):用合并排序法对两个子序列递归的排序。
- 合并(Combine):合并两个已排序的子序列已得到排序结果。
def merge(li, low, mid, high):
i = low
j = mid+1
tmp = []
while i<=mid and j<=high:#只要两边都有数
if li[i]<li[j]:
tmp.append(li[i])
i += 1
else:
tmp.append(li[j])
j += 1
#执行完之后肯定有一边没数了
while i<=mid:
tmp.append(li[i])
i += 1
while j<=high:
tmp.append(li[j])
j += 1
li[low:high+1] = tmp
def merge_sort(li, low, high):
if low<high:#至少有两个元素,递归
mid = (low+high)//2
merge_sort(li, low, mid)
merge_sort(li, mid+1, high)
merge(li, low, mid, high)