版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/m0_37886429/article/details/82753371
算法（Algorithm）：一个计算过程，解决问题的方法
时间复杂度：用来评估算法运行效率的一个式子（单位）。
一般来说，时间复杂度高的算法比复杂度低的算法快。
常见的时间复杂度（按效率排序）
O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)
列表查找
- 定义：从列表中查找指定元素
- 输入：列表、待查找元素
- 输出：元素下标或未查找到元素
时间复杂度为：O(n)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random
def linear_search(data, value):
for i in range(len(data) - 1 ):
if data[i] == value:
return i #返回索引位置
return
data= list(range(5000))
random.shuffle(data) #将列表打乱
ret = linear_search(data,4000) #从列表中找 4000
print(ret)
二分查找
- 从有序列表的候选区下data[0:n]下开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。
时间复杂度为：O(logn)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random
def bin_search(data,val):
low = 0 #最小索引位置
high = len(data) - 1 #最大索引位置
while low <= high:
mid = (low+high) // 2
if data[mid] == val:
return mid
elif data[mid] > val: #中间数比给定的数大，证明在左边
high = mid - 1
else:
low = mid + 1
data = list(range(50000))
ret=bin_search(data,300)
print(ret)
冒泡排序
- 列表每两个相邻的数，如果前边的比后边的大，那么交换这两个数
时间复杂度为：O(n2)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random,time
def timmer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
ret = func(*args,**kwargs)
stop_time = time.time()
print("%s cost time is:" %(func.__name__),stop_time - start_time)
return ret
return wrapper
@timmer
def bubble_sort(data):
for i in range(len(data)-1):
for j in range(len(data)-i-1):
if data[j] > data[j+1]:
data[j], data[j+1] = data[j+1], data[j]
data = list(range(5000))
random.shuffle(data) #打乱列表
bubble_sort(data)
优化版：
如果冒泡排序中执行一趟而没有交换，则列表已经是有序状态，可以直接结束算法。
时间复杂度一般情况为：O(n2)，特殊情况下可以优化到O(n)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random,time
def timmer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
ret = func(*args,**kwargs)
stop_time = time.time()
print("%s cost time is:" %(func.__name__),stop_time - start_time)
return ret
return wrapper
@timmer
def bubble_sort(data):
for i in range(len(data)-1):
exchage = False
for j in range(len(data)-i-1):
if data[j] > data[j+1]:
data[j], data[j+1] = data[j+1], data[j]
exchage = True
if not exchage:
return
data = list(range(5000))
random.shuffle(data) #打乱列表
bubble_sort(data)
选择排序
- 一趟遍历记录最小的数，放到第一个位置；
- 再一趟遍历记录剩余列表中最小的数，继续放置；
时间复杂度为：O(n2)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random,time
def timmer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
ret = func(*args,**kwargs)
stop_time = time.time()
print("%s cost time is:" %(func.__name__),stop_time - start_time)
return ret
return wrapper
@timmer
def select_sort(data):
for i in range(len(data)-1):
min_loc = i
for j in range(i+1,len(data)):
if data[j] < data[min_loc]:
min_loc = j
if min_loc != i:
data[i],data[min_loc] = data[min_loc],data[i]
data = list(range(5000))
random.shuffle(data) #打乱列表
select_sort(data)
快排
时间复杂度一般情况为：O(nlogn)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random,time
def timmer(func):
def wrapper(*args,**kwargs):
start_time = time.time()
ret = func(*args,**kwargs)
stop_time = time.time()
print("%s cost time is:" %(func.__name__),stop_time - start_time)
return ret
return wrapper
@timmer
def quick_sort(data, left, right):
if left < right:
mid = partition(data, left, right)
quick_sort(data, left, mid - 1)
quick_sort(data, mid + 1, right)
def partition(data, left, right):
tmp = data[left]
while left < right:
while left < right and data[right] >= tmp:
right -= 1
data[left] = data[right]
while left < right and data[left] <= tmp:
left += 1
data[right] = data[left]
data[left] = tmp
return left
data = list(range(500000))
random.shuffle(data)
quick_sort(data,0,len(data)-1)