1. 二分查找法
def bin_serch(x,val):
'''
x:带查找列表
val:目标元素
return: 目标元素的索引
'''
left=0
right=len(x)-1
while left <=right:
mid = (left + right) // 2
if x[mid] ==val:
return mid
elif x[mid]> val:
right = mid-1
else:
left = mid+1
return None
2. 冒泡排序
def bubble_search(x):
'''
x:带查找列表
return :从小到大排序好的列表
'''
for i in range(len(x)-1): # 遍历的趟
flag =False # 减少不必要的交换
for j in range(len(x)-i-1): #遍历的箭头 指针
if x[j] > x[j+1]:
x[j],x[j+1] =x[j+1],x[j]
flag=True
if not flag:
return x
return x
3. 选择排序
def select_search_sample(li):
'''
li: 待排序列表
return 排序好的新列表
'''
new_li=[]
for i in range(len(li)):
min_val = min(li)
li.remove(min_val)
new_li.append(min_val)
return new_li
def select_search(li):
'''
li: 待排序列表
return 从小到大排序好的列表,未开辟新的内存存放新列表
'''
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
if i != min_loc:
li[i],li[min_loc]=li[min_loc],li[i]
return li
4. 插入排序
def insert_sort(li):
'''
li: 待排序元素
return 排序好的元素
'''
for i in range(1,len(li)): #遍历 当前值后面的所有元素的下标
tmp = li[i] # 当前拿到的元素
j = i-1 # 前一个值的下标
while j >=0 and li[j] > tmp:
li[j+1] = li[j]
j -=1
li[j+1] = tmp
return li
5. 快速排序
def quick_sort(li,first,last):
'''
li:待排序列表
first:首元素坐标 0
last: 末元素坐标 len(li)-1
return 排序好元素
'''
if first>=last:
return
left = first
right = last
mid = li[first]
while left < right:
while left < right and li[right] >= mid:
right -=1
li[left] = li[right]
while left < right and li[left] < mid:
left +=1
li[right] = li[left]
li[left] = mid
# 递归之前的代码是 找到一个中间值,把小于其值的元素放在左边,大于其值的元素放在右边
# 递归左右两边的元素使得全部数据不可再分为止
quick_sort(li, first, left - 1)
# low 右边元素
quick_sort(li, left + 1, last)
#return li
6. 堆排序
'''详细介绍'''
# 满二叉树 就是每个节点有且仅有两个分支
# 完全二叉树 并不一定是满二叉树,即可以在一个满二叉树的最后部分拿掉几个分支,但不能从中间拿掉一些分支
# 父亲和左孩子节点下标对应的关系 2*i+1 和右孩子节点下标对应 的关系2*i+2
# 堆排序 需要再次看
def sift(li,low,high):
'''
li:待排序列表
low:首元素坐标 0
high:末元素坐标 len(li) -1
'''
i = low # i z最开始指向根节点
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
# 堆排序实现前k大的数
def topk(li,k):
heap = li[0:k]
#建堆
for i in range((k-2)//2,-1,-1):
sift(heap,i,k-1)
# 遍历
for i in range(k,len(li)-1):
if li[i] >heap[0]:
heap[0] = li[i]
sift(heap,0,k-1)
# 出数
for i in range(k-1,-1,-1):
heap[0],heap[i] = heap[i],heap[0]
sift(heap,0,i-1)
return heap
7. 归并排序
def merge(li,low,mid,high):
# 定义两个指针,分别指向两段有序列表的头位置
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 i <= mid:
ltmp.append(li[i])
i +=1
while j <= high:
ltmp.append(li[j])
j+=1
# 将结果写入原始的列表
li[low:high+1] = ltmp
return 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,mid,high)
return li
8. 希尔排序
# 希尔排序 分组的插入排序
def insert_sort_gap(li,gap):
'''
li:待排序列表
gap:分组间隔
'''
for i in range(gap,len(li)):
tmp = li[i]
j = i-gap
while j >=0 and li[j]>tmp:
li[j+gap] = li[j]
j -=gap
li[j+gap]= tmp
return li
def shell_sort(li):
d = len(li)//2
while d >=1:
insert_sort_gap(li,d)
d //=2
return li
9. 计数排序
def count_sort(li):
'''
li:待排序列表
return 排好序的列表
'''
ltmp =(len(li)+1)*[0]
for i in li:
ltmp[i] +=1
li.clear()
for ind,val in enumerate(ltmp):
for i in range(val):
li.append(ind)
return li
10. 桶排序
def bucket_sort(li,n=10,max_num=100):
'''
li:待排序列表
n:桶的个数
max_num:待排序列表中的最大数
return 排序好的新列表
'''
buckets=[[]for _ in range(n)]
num = max_num//n
for val in li:
ind = min(val // num,n-1)
buckets[ind].append(val)
# 将元素 有序的放入桶内
for j in range(len(buckets[ind])-1,0,-1):
if buckets[ind][j] < buckets[ind][j-1]:
buckets[ind][j],buckets[ind][j-1] = buckets[ind][j-1],buckets[ind][j]
else:
break
sorted_li =[]
for buc in buckets:
sorted_li.extend(buc)
return sorted_li