常见排序整合(python版）
1.冒泡排序
#bubble sort
#时间复杂度为o(n^2)
#升序和降序只需要改动其中的一个箭头方向即可
def bubble_sort(li):
count=1
for i in range(len(li)-2):
exchange=False
for j in range (len(li)-i-1):
if li[j]>li[j+1]:
li[j],li[j+1]=li[j+1],li[j]
exchange=True
print(f"排序第{count}趟的列表为{li}")
count=count+1
if not exchange:
return
import random
list1=[random.randint(0,100) for i in range(10)]
print(f"初始列表为{list1}")
bubble_sort(list1)
print(f"排序之后的结果为{list1}")
2.选择排序
#select sort
def select_sort_simple(li):#简单版
li_new=[]
for i in range(len(li)):
min_val=min(li)
li_new.append(min_val)
li.remove(min_val)
return li_new
def select_sort(li):
for i in range(len(li)-1):
min_loc=i
for j in range (i+1,len(li)):
if li[j]<li[min_loc]:
min_loc=j
li[i],li[min_loc]=li[min_loc],li[i]
print(f"第{i+1}次：{li}")
list1=[1,2,1,6,7,99,34,66,11]
select_sort_simple(list1)
print(list1)
3.插入排序
#insert sort
#时间复杂度o（n^2）
import random
def insert_sort(li):
for i in range(1,len(li)):# i表示摸到牌的下标
tmp=li[i]
j=i-1 #j是手里牌的下标
while li[j]>tmp and j>=0:
li[j+1]=li[j]
j-=1
li[j+1]=tmp
li=list(range(10000))
random.shuffle(li)
print(li)
insert_sort(li)
print(li)
4.快速排序
#quick sort
#快速排序的时间复杂度o(logn*n)
def partition(li,left,right):
tmp=li[left]
while left<right:
while left<right and li[right]>=tmp:#从右边找比tmp小的数
right -=1 #往左走一步
li[left]=li[right] #把左边数写到右边空位上
#print(li,'right')
while left<right and li[left]<=tmp:
left +=1
li[right]=li[left] #把左边的值写道右边空位上
#print(li,'left')
li[left]=tmp #把tmp归位
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)
li=[5,3,6,4,7,1,9,2,8]
print(li)
quick_sort(li,0,len(li)-1)
print(li)
5.归并排序
def merge(li,low,high,mid):
i=low
j=mid+1
ltmp=[]
while i<=mid and j<=high:
if li[i]<li[j]:
ltmp.append(li[i])
i+=1
else:
ltmp.append(li[j])
j+=1
#while执行完，肯定有一部分没数了
while i<=mid:
ltmp.append(li[i])
i+=1
while j<=high:
ltmp.append(li[j])
j+=1
li[low:high+1]=ltmp
import random
li=list(range(1000))
random.shuffle(li)
print(li)
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,high,mid)
merge_sort(li,0,len(li)-1)
print(li)
#时间复杂度o（nlogn)
#空间复杂度o（n）
6.堆排序
#堆排序前传——二叉树
#父节点与左孩子节点的编号下标有什么关系 ？
#i->2i+1
#父节点和右孩子节点的编号下标有什么关系？
#i->2i+2
#heap sort 时间复杂度o(nlog(n))
def sift(li,low,high):
"""
:param li: 列表
:param low: 堆的根节点位置
:param high: 堆的最后一个元素的位置
:return:
"""
i=low
j=2*i+1 #j开始是左孩子
tmp=li[low] #将堆顶存起来
while j<=high:#只要j位置有数
if j+1<=high and li[j+1]>li[j]:#右孩子有且比较大
j=j+1 #j指向右孩子
if li[j]>tmp:
li[i]=li[j]
i=j
j=2*i+1
else: #tmp更大，把tmp放到i的位置上
li[i]=tmp #把tmp放到某一级领导位置
break
else:
li[i]=tmp #把tmp放在叶子结点上
def heap_sort(li):
n=len(li)
for i in range((n-2)//2,-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
li=[i for i in range(100)]
import random
random.shuffle(li)
print(li)
heap_sort(li)
print(li)
7.堆排序内置模块
#堆排序的内置模块
import heapq #q->queue 优先队列
import random
li=list(range(100))
random.shuffle(li)
print(li)
heapq.heapify(li)#建堆
n=len(li)
for i in range(n):
print(heapq.heappop(li),end=',')
8.堆排序—topk问题
#现在有n个数，设计算法得到前k大的数
#解决思路：1.排序后切片 时间复杂度o（nlogn）2.排序lowb三人组 o（kn）3.堆排序 （nlogk）
def sift(li,low,high):
"""
:param li: 列表
:param low: 堆的根节点位置
:param high: 堆的最后一个元素的位置
:return:
"""
i=low
j=2*i+1 #j开始是左孩子
tmp=li[low] #将堆顶存起来
while j<=high:#只要j位置有数
if j+1<=high and li[j+1]<li[j]:#右孩子有且比较大
j=j+1 #j指向右孩子
if li[j]<tmp:
li[i]=li[j]
i=j
j=2*i+1
else: #tmp更大，把tmp放到i的位置上
li[i]=tmp #把tmp放到某一级领导位置
break
else:
li[i]=tmp #把tmp放在叶子结点上
def topk(li,k):
heap=li[0:k]
for i in range((k-2)//2,-1,-1):
sift(heap,i,k-1)
#1.建堆
for i in range(k,len(li)-1):
if li[i]>heap[0]:
heap[0]=li[i]
sift(heap,0,k-1)
#2.遍历
for i in range(k-1,-1,-1):
#i 指向当前堆的最后一个元素
heap[0],heap[i]=heap[i],heap[0]
sift(heap,0,i-1)#i-1是新的high
#3.出数
return heap
def heap_sort(li):
n=len(li)
for i in range((n-2)//2,-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
import random
li=list(range(1000))
random.shuffle(li)
print(topk(li,10))
9.希尔排序
#时间复杂度情况复杂
import random
def insert_sort(li,gap):
for i in range(gap,len(li)):# i表示摸到牌的下标
tmp=li[i]
j=i-gap #j是手里牌的下标
while li[j]>tmp and j>=0:
li[j+gap]=li[j]
j-=gap
li[j+gap]=tmp
def shell_sort(li):
d=len(li)//2
while d>=1:
insert_sort(li,d)
d//=2
li=list(range(10000))
random.shuffle(li)
print(li)
shell_sort(li)
print(li)
10.计数排序
#时间复杂度o（n）
def count_sort(li,max_count):
count =[0 for _ in range(max_count+1)]
for val in li:
count[val]+=1
li.clear()
for ind,val in enumerate(count):
for i in range(val):
li.append(ind)
import random
li=[random.randint(0,100) for _ in range(1000)]
print(li)
count_sort(li,max(li))
print(li)
11.桶排序
#时间复杂度o（nk）
def bucket_sort(li,n=100,maxnum=100):
buckets=[[]for _ in range(n)]#创建桶
for var in li:
i=min(var//(maxnum//n),n-1)#i 表示var在几号桶里
buckets[i].append(var)#把var加到桶里
#保持桶里的顺序
for j in range(len(buckets[i])-1,0,-1):
if buckets[i][j]<buckets[i][j-1]:
buckets[i][j],buckets[i][j-1]=buckets[i][j-1],buckets[i][j]
else:
break
sorted_li=[]
for buc in buckets:
sorted_li.extend(buc)
return sorted_li
import random
li=[random.randint(0,10000) for i in range(10000)]
li=bucket_sort(li)
print(li)
12.基数排序
#基数排序
#时间复杂度o（kn）
def radix_sort(li):
max_num=max(li)#最大数99->2,888->3,10000->5
it=0
while 10**it<=max_num:
buckets=[[]for _ in range(10)]
for var in li:
digit=(var//10**it)%10
buckets[digit].append(var)
#分桶完毕
li.clear()
for buc in buckets:
li.extend(buc)
#把数据重新写回li
it+=1
import random
li=list(range(1000))
random.shuffle(li)
radix_sort(li)
print(li)
#快速排序的logn是log（2，n)
#基数排序的k是log（10，n）
目前的个人观点：先学一遍python的排序，为啥呢，因为python简单🤣，可以更好的掌握各个排序的意思。
