二分查找
时间复杂度为O(logN)
递推公式:
f(N) = f(N/2) + O(1) = f(N/4) + 2 * O(1)
假设 N = 2 ^ M
最后可以推出
f(N) = O(logN)
// O(N)
def LinearSearch(array, t):
for i in range(len(array)):
if array[i] == t:
return True
return False
// O(logN)
def BinarySearch(array, t):
left = 0
right = len(array) - 1
while left <= right:
mid = int((left + right) / 2)
if array[mid] < t:
left = mid + 1
elif array[mid] > t:
right = mid - 1
else:
return True
return False
递归实现
left是搜索的起始下标,right是搜索的结尾下标
def RecursiveBinarySearch(array, t, left, right):
if left <=right:
# 数组中间元素的下标
mid = int((left + right) / 2)
if array[mid] < t:
RecursiveBinarySearch(array, t, mid+1, right)
elif array[mid] > t:
RecursiveBinarySearch(array, t, left, mid-1)
else:
return mid
return -1
array = list(range(100000000))
import time
t1 = time.time()
LinearSearch(array, 100000001)
t2 = time.time()
print('线性查找:', t2 - t1)
t3 = time.time()
BinarySearch(array, 100000001)
t4 = time.time()
print('二分查找:', t4 - t3)
快速排序
# 时间复杂度__O(NlogN)
def partition(A, p, r):
# x为分割操作的哨兵
x = A[r]
i = p - 1
# 从p遍历到r-1,也就是说不遍历哨兵
for j in range(p, r):
if A[j] <= x:
i += 1
A[i], A[j] = A[j], A[i]
A[i + 1], A[r] = A[r], A[i + 1]
return i + 1
def quick_sort(A, p, r):
if p < r:
q = partition(A, p, r)
quick_sort(A, p, q - 1)
quick_sort(A, q + 1, r)
A = [2, 45, 6, 2, 7, 2, 7, 8, 4]
quick_sort(A, 0, 8)
print(A)
插入排序
# 时间复杂的__O(N^2)
def insert_sort(A):
for i in range(1, len(A)):
key = A[i]
j = i - 1
while A[j] > key and j >= 0:
A[j + 1] = A[j]
j -= 1
A[j + 1] = key
return A
A = [2, 45, 6, 2, 7, 2, 7, 8, 4]
print(insert_sort(A))