一.查找
1.顺序查找(线性查找)O(n)
##li=[4,5,6,9,3,7],查找9
def search(li, val):
for i in range(len(li)):
if li[i]==val:
return i
return -1
>>> 3
2.二分查找 O(logn)
##li = [1,3,6,9,44,67,88](列表要有序),查找9
def bin_search(li, val):
low = 0
high = len(li) - 1
while low <= high:
mid = (low + high) // 2
if li[mid] == val:
print(mid)
return mid
elif li[mid] < val:
low = mid + 1
else:
high = mid - 1
else:
print("没有这个值")
>>>3
二.排序
lowB三人组
1.冒泡排序
在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现他们的排序与排序要求相反时,就将他们互换。
1.比较相邻的元素。如果第一个比第二个大,就交换它们两个;
2.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
3.针对所有的元素重复以上的步骤,除了最后一个;
4.重复步骤1~3,直到排序完成。
##最好情况O(n) # 列表有序
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def bubble_sort(li):
for i in range(len(li)-1):
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
if not exchange:
break
return li
li = list(range(15))
random.shuffle(li)
print(li)
res = bubble_sort(li)
print(res)
2.选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:
1.初始状态:无序区为R[1..n],有序区为空;
2.第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
3.n-1趟结束,数组有序化了。
##最好情况O(n^2)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:不稳定
import random
def select_sort(li):
for i in range(len(li)-1):
min_pos = i
for j in range(i+1, len(li)):
if li[j] < li[min_pos]:
min_pos = j
li[i], li[min_pos] = li[min_pos], li[i]
return li
li = list(range(15))
random.shuffle(li)
print(li)
res = select_sort(li)
print(res)
3.插入排序
将一个记录插入到已排序好的有序表中,从而得到一个新的,记录数增1的有序表。即先将序列的第一个记录看成是一个有序的子序列,然后从第二个记录逐个进行插入,直至整个序列有序为止。
1.从第一个元素开始,该元素可以认为已经被排序;
2.取出下一个元素,在已经排序的元素序列中从后向前扫描;
3.如果该元素(已排序)大于新元素,将该元素移到下一位置;
4.重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
5.将新元素插入到该位置后;
6.重复步骤2~5。
##最好情况O(n)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def insert_sort(li):
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
li = list(range(15))
random.shuffle(li)
print(li)
res = insert_sort(li)
print(res)
NB三人组
1.快速排序
选择一个基准元素,将比基准元素小的元素放在其前面,比基准元素大的元素放在其后面,然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序,直到整个序列有序;
快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:
1.从数列中挑出一个元素,称为 “基准”(pivot);
2.重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
3.递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(n^2) # 列表有序并倒序(从小到大排序)
##稳定性:不稳定
##方法一
import random
def quicksort(li, left, right):
if left < right:
mid = random_partition(li, left, right)
quicksort(li, left, mid-1)
quicksort(li, mid+1, right)
return li
#优化快排最坏情况
def random_partition(li, left, right):
i = random.randint(left, right)
li[i], li[left] = li[left], li[i]
return partition(li, left, right)
def partition(li, left, right):
tmp = li[left]
while left < right:
while left < right and li[right] >= tmp:
right -= 1
li[left] = li[right]
while left < right and li[left] <= tmp:
left += 1
li[right] = li[left]
li[left] = tmp
return left
li = list(range(15))
random.shuffle(li)
print(li)
res = quicksort(li,0,len(li))
print(res)
##方法二
import random
def quick_sort(li):
if len(li) < 2:
return li
temp = li[0]
left = [v for v in li[1:] if v <= temp]
right = [v for v in li[1:] if v > temp]
left = quick_sort(left)
right = quick_sort(right)
return left + [temp] + right
li = list(range(15))
random.shuffle(li)
print(li)
res = quick_sort(li)
print(res)
2.堆排序
二叉堆是完全二叉树或近似完全二叉树。二叉堆满足两个特性:
(1)父结点的键值总是大于或者等于(小于或者等于)任何一个子节点的键值;
(2)每个结点的左子树和右子树都是一个二叉堆;
当父结点的键值总是大于或者等于任何一个子节点的键值时为大根堆。当父结点的键值总是小于或等于任何一个子节点的键值时为小根堆;
##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(nlogn)
##稳定性:不稳定
#大根堆
def sift(li, low, high):
tmp = li[low]
i = low
j = 2 * i + 1
while j <= high:
if j + 1 <= high and li[j] < li[j+1]:
j += 1
if li[j] > tmp:
li[i] = li[j]
i = j
j = 2 * i + 1
else:
break
li[i] = tmp
def heap_sort(li):
n = len(li)
for low in range((n-1)//2, -1, -1):
sift(li, low, n-1)
print(li)
for high in range(n-1, -1, -1):
li[0], li[high] = li[high], li[0]
sift(li, 0, high-1)
import random
li = list(range(15))
random.shuffle(li)
print(li)
heap_sort(li)
print(li)
#小根堆
def sift(li, low, high):
tmp = li[low]
i = low
j = 2 * i + 1
while j <= high:
if j + 1 <= high and li[j] > li[j+1]:
j += 1
if li[j] < tmp:
li[i] = li[j]
i = j
j = 2 * i + 1
else:
break
li[i] = tmp
def heap_sort(li):
n = len(li)
for low in range(n//2-1, -1, -1):
sift(li, low, n-1)
print(li)
for high in range(n-1, -1, -1):
li[0], li[high] = li[high], li[0]
sift(li, 0, high-1)
import random
li = list(range(15))
random.shuffle(li)
print(li)
heap_sort(li)
print(li)
#PS:python heapq 模块可以实现小根堆
3.归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
1.把长度为n的输入序列分成两个长度为n/2的子序列;
2.对这两个子序列分别采用归并排序;
3.将两个排序好的子序列合并成一个最终的排序序列。
##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(nlogn)
##稳定性:稳定
import random
def merge(li, low, mid, high):
i = low
j = mid + 1
li_tmp = []
while i <= mid and j<=high:
if li[i] <= li[j]:
li_tmp.append(li[i])
i += 1
else:
li_tmp.append(li[j])
j += 1
while i <= mid:
li_tmp.append(li[i])
i += 1
while j <= high:
li_tmp.append(li[j])
j += 1
li[low:high+1] = li_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)
ll = list(range(16))
random.shuffle(ll)
print(ll)
merge_sort(ll, 0, len(ll)-1)
print(ll)
其他排序
1.希尔排序
1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:
1.选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
2.按增量序列个数k,对序列进行k 趟排序;
3.每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
def insert_sort_gap(li, d):
for i in range(d, len(li)):
tmp = li[i]
j = i - d
while j >= 0 and li[j] > tmp:
li[j+d] = li[j]
j -= d
li[j+d] = tmp
return li
def shell_sort(li):
d = len(li) // 2
while d > 0:
res = insert_sort_gap(li, d)
d //= 2
return res
import random
li = list(range(20))
random.shuffle(li)
res = shell_sort(li)
print(res)