目录
一、查找
1、顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止。
2、二分查找：也叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。
二、排序
1、冒泡排序（原地排序）
2、选择排序
3、插入排序
4、快速排序
一、查找
查找：在一些数据元素中、通过一定的方法找出与给定关键字相同数据元素的过程
列表查找（线性表查找）：从列表中查找指定元素
输入：列表、待查找元素
输出：元素下标（未找到元素时一般返回None或-1）
内置列表查找函数：index（）（底层就是顺序查找，因为二分查找需要有序列表）
1、顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止。
顺序查找例子：
def linea_search(li, val):
for index, v in enumerate(li):
if v == val:
return index
else:
return None
# print(index)
# print(v)
if __name__ == '__main__':
line = linea_search([1, 2, 3, 4, 5, 6, 7], 7)
print(line)2、二分查找：也叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。
二分查找例子：
def binary_search(list, val):
left = 0
right = len(list) - 1
while left <= right:
mid = (left + right) // 2
if list[mid] == val:
return mid
elif list[mid] > val:
right = mid - 1
else:
left = mid + 1
else:
return None
if __name__ == '__main__':
a = binary_search([1, 2, 3, 4, 5, 6], 3)
print(a)
二、排序
- 什么是列表排序
- 常见排序算法
- 排序算法分析
排序：将一组“无序”的记录序列调整为“有序”的记录序列
列表排序：将无序列表变为有序列表
输入：列表
输出：有序列表
升序（小到大）、降序（大到小）
内置排序函数：sort（）
常见排序算法：
冒泡排序、选择排序、插入排序
快速排序、堆排序、归并排序
希尔排序、计数排序、基数排序
1、冒泡排序（原地排序）
-
列表每相邻的两个数，如果前面的比后面的大，则交换这两个数
-
一趟排序完成后，无序区少一个数，有序区多一个数
import random
def buffer_search(n):
for i in range(len(n) - 1): # 趟数
exchange = False
for j in range(len(n) - i - 1):
if n[j] > n[j + 1]:
n[j], n[j + 1] = n[j + 1], n[j]
exchange = True
else:
exchange = False
if not exchange:
break
print(n)
if __name__ == '__main__':
# li = [random.randint(0, 10000) for i in range(10)]
# print("len(li):", len(li))
# print(li)
# buffer_search(li)
# print(li)
li2 = [9, 8, 7, 1, 2, 3, 4, 5, 6]
buffer_search(li2)Note：
- 整个冒泡排序只需要走n-1躺，因为最后剩下的一定是最小的
- 代码关键点：趟数、无序区范围
- 趟数n-1
- 第一趟可以确定一个数到有序区，那么无序区范围是n-i-1，还剩n-i个数
- 复杂度O（n^2）
- 改进点：如果列表中没有发生数字的交换、那么就是已经排好序了，例如： li2 = [9, 8, 7, 1, 2, 3, 4, 5, 6]
2、选择排序
- 每一趟选择一个最小的放入新列表
def select_search_1(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缺点：remove（）操作和min（）操作，增大了开销，并且增加了一个新列表li_new[]。不是原地排除
改进：
def select_search_2(li):
'''改进'''
for i in range(len(li)):
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('i:%s,li:%s', i, li)- 原地排序，第一趟，找到无序区最小的数与第一个数进行交换位置，第二趟找到无序区最小的数与第二个位置进行交换，以此类推
- 将列表在排序的过程中划分为了有序区和无序区
- 时间复杂度O（n^2）
3、插入排序
- 初始时手里（有序区）只有一张牌
- 每次（从无序区）摸一张牌，插入到自己手里已经有牌的正确位置
def inseart_search(list):
for i in range(1, len(list)):
temp = list[i]
j = i - 1
while j >= 0 and list[j] > temp:
list[j + 1] = list[j]
j -= 1
list[j + 1] = temp
print(list)
if __name__ == '__main__':
list = [3, 2, 5, 7, 4, 1, 9, 8, 6]
inseart_search(list)Note：
for i in range(1, len(list)):
- i 表示摸到的牌的下标
j = i - 1
- j指的是手里的牌的下标
- 时间复杂度O（n^2）
4、快速排序
- 快速排序思路：
- 取一个元素p（第一个元素），使元素p归位
- 列表被p分成两部分，左边都比p小，右边都比p大
- 递归完成排序
- 时间复杂度：O（nlogn）
- 快速排序问题：
- 递归
- 最坏情况：例如 [9,8,7,6,5,4,3,2,1] 这时候时间复杂度为 O(n^2)
- 解决思路：随机找一个数与第一个数进行先交换，在进行快速排序。
def partition(list, left, right):
temp = list[left] # 存值
while left < right:
while left < right and list[right] >= temp:
right -= 1
list[left] = list[right]
while left < right and list[left] <= temp:
left += 1
list[right] = list[left]
list[left] = temp
return left
def quick_sort(list, left, right):
if left < right:
mid = partition(list, left, right)
quick_sort(list, mid + 1, right)
quick_sort(list, left, mid - 1)
if __name__ == '__main__':
list = [3, 2, 5, 6, 8, 9, 1, 7, 4]
# 单步测试
# partition(list, 0, len(list) - 1)
# print(list)
quick_sort(list, 0, len(list) - 1)
print(list)
