Python 查找算法_众里寻他千百度，蓦然回首那人却在灯火阑珊处（线性、二分，分块、插值查找算法)

查找算法是用来检索

序列数据（群体）

关键字

• 线性查找：

  线性查找

  也称为顺序查找，用于在

  无序数列

  中查找。
• 二分查找：

  二分查找

  也称为

  折半查找

  ，其算法用于

  有序数列

  。
• 插值查找：

  插值查找

  是对

  二分查找

  算法的改进。
• 分块查找： 又称为

  索引顺序查找

  ，它是

  线性查找

  的改进版本。
• 树表查找：

  树表查找

  又可分

  二叉查找树

  、

  平衡二叉树

  查找。
• 哈希查找：

  哈希查找

  可以直接通过关键字查找到所需要数据。

因

树表查找

哈希查找

树表

哈希

1. 线性查找

线性查找

顺序查找

线性查找

线性查找思想：

• 从头至尾逐一扫描原始列表中的每一个数据，并和给定的关键字进行比较。
• 如果比较相等，则查找成功。
• 当扫描结束后，仍然没有找到与给定关键字相等的数据，则宣布查找失败。

根据

线性查找

'''
线性查找算法
参数：
nums: 序列
key:关键字
返回值：
关键字在序列中的位置
如果没有，则返回 -1
'''
def line_find(nums, key):
for i in range(len(nums)):
if nums[i] == key:
return i
return -1
'''
测试线性算法
'''
if __name__ == "__main__":
nums = [4, 1, 8, 10, 3, 5]
key = int(input("请输入要查找的关键字："))
pos = line_find(nums, key)
print("关键字 {0} 在数列的第 {1} 位置".format(key, pos))
'''
输出结果：
请输入要查找的关键字：3
关键字 3 在数列的 4 位置
'''

线性查找

• 运气最好的情况：如果要查找的关键字恰好在数列的第

  1

  个位置，则只需要查找 1 次就可以了。

  如在数列=

  [4,1,8,10,3,5]

  中查找关键字

  4

  。

  只需要查找

  1

  次。

• 运气最不好的情况：一至扫描到数列最尾部时，才找到关键字。

  如在数列=

  [4,1,8,10,3,5]

  中查找是否存在关键字

  5

  。

  则需要查找的次数等于数列的长度，此处即为

  6

  次。

• 运气不好不坏：如果要查找的关键字在数列的中间某个位置，则查找的概率是

  1/n

  。

  n

  为数列长度。

线性查找

(1+n)/2

O

O(n)

O

线性查找

[4,1,8,10,3,5]

12

6

改良线性查找算法

可以对

线性查找

def line_find_(nums, key):
i = 0
while nums[i] != key:
i += 1
return -1 if i == len(nums)-1 else i

'''
测试线性算法
'''
if __name__ == "__main__":
nums = [4, 1, 8, 10, 3, 5]
key = int(input("请输入要查找的关键字："))
# 查找之前，先把关键字存储到列到的尾部
nums.append(key)
pos = line_find_(nums, key)
print("关键字 {0} 在数列的第 {1} 位置".format(key, pos))

用"前哨站"优化后的线性查找算法的时间复杂度没有变化，O(n)。或者说从

2

但从代码的实际运行角度而言，第

2

if

CPU

CPU

2. 二分查找

二分查找

有序查找

有序查找

[4,1,8,10,3,5,12]

4

二分查找

二分查找

二分查找

二分（折半）算法

二分查找

2

• 一个是数列的中间位置

  mid_pos

  。
• 一个是数列的中间值

  mid_val

  。

现在通过在数列

nums=[1,3,4,5,8,10,12]

8

二分查找

在进行

二分查找

2

• 左指针

  l_idx

  初始指向数列的最左边数字。
• 右指针

  r_idx

  初始指向数列的最右边数字。

**第

1

mid_pos=3

mid_pos

mid_val=nums[mid_pos]

5

二分查找

**第

2

8

5

8

5

5

5

第

3

第 4 步：重复上述步骤，至到找到或找不到为止。

编码实现二分查找算法

'''
二分查找算法
'''
def binary_find(nums, key):
# 初始左指针
l_idx = 0
# 初始在指针
r_ldx = len(nums) - 1
while l_idx <= r_ldx:
# 计算出中间位置
mid_pos = (r_ldx + l_idx) // 2
# 计算中间位置的值
mid_val = nums[mid_pos]
# 与关键字比较
if mid_val == key:
# 出口一：比较相等，有此关键字，返回关键字所在位置
return mid_pos
elif mid_val > key:
# 说明查找范围应该缩少在原数的左边
r_ldx = mid_pos - 1
else:
l_idx = mid_pos + 1
# 出口二：没有查找到给定关键字
return -1

'''
测试二分查找
'''
if __name__ == "__main__":
nums = [1, 3, 4, 5, 8, 10, 12]
key = 3
pos = binary_find(nums, key)
print(pos)

通过前面对

二分算法

二分查找

子问题

原始问题

'''
递归实现二分查找
'''
def binary_find_dg(nums, key, l_idx, r_ldx):
if l_idx > r_ldx:
# 出口一：没有查找到给定关键字
return -1
# 计算出中间位置
mid_pos = (r_ldx + l_idx) // 2
# 计算中间位置的值
mid_val = nums[mid_pos]
# 与关键字比较
if mid_val == key:
# 出口二：比较相等，有此关键字，返回关键字所在位置
return mid_pos
elif mid_val > key:
# 说明查找范围应该缩少在原数的左边
r_ldx = mid_pos - 1
else:
l_idx = mid_pos + 1
return binary_find_dg(nums, key, l_idx, r_ldx)
'''
测试二分查找
'''
if __name__ == "__main__":
nums = [1, 3, 4, 5, 8, 10, 12]
key = 8
pos = binary_find_dg(nums, key,0,len(nums)-1)
print(pos)

二分查找性能分析：

二分查找

1. 如上述代码执行过程中，先找到数列中的中间数字

   5

   ，然后以

   5

   为根节点构建唯一结点树。

1. 5

   和关键字

   8

   比较后，再在以数字

   5

   为分界线的右边数列中找到中间数字

   10

   ，树形结构会变成下图所示。

1. 10

   和关键字

   8

   比较后，再在

   10

   的左边查找。

查找到

8

3

从二叉树的结构上可以直观得到结论：二分查找关键字的次数由关键字在二叉树结构中的深度决定。

1. 上述是查找给定的数字

   8

   ，为了能查找到数列中的任意一个数字，最终完整的树结构应该如下图所示。

很明显，树结构是标准的二叉树。从树结构上可以看出，无论查找任何数字，最小是

1

5

3

根据二叉树的特性，结点个数为

n

O

O(logn)

当对长度为

1000

10

二分查找

但是，

二分查找

3. 插值查找

插值查找

二分查找

插值查找

二分查找

原生

二分查找

2

# 计算中间位置
mid_pos = (r_ldx + l_idx) // 2

插值算法

key

# 插值算法中计算中间位置
mid_pos = l_idx + (key - nums[l_idx]) // (nums[r_idx] - nums[l_idx]) * (r_idx - l_idx)

编码实现插值查找：

# 插值查找基于二分法，只是mid计算方法不同
def binary_search(nums, key):
l_idx = 0
r_idx = len(nums) - 1
old_mid = -1
mid_pos = None
while l_idx < r_idx and nums[0] <= key and nums[r_idx] >= key and old_mid != mid_pos:
# 中间位置计算
mid_pos = l_idx + (key - nums[l_idx]) // (nums[r_idx] - nums[l_idx]) * (r_idx - l_idx)
old_mid = mid_pos
if nums[mid_pos] == key:
return "index is {}, target value is {}".format(mid_pos, nums[mid_pos])
# 此时目标值在中间值右边，更新左边界位置
elif nums[mid_pos] < key:
l_idx = mid_pos + 1
# 此时目标值在中间值左边，更新右边界位置
elif nums[mid_pos] > key:
r_idx = mid_pos - 1
return "Not find"

li =[1, 3, 4, 5, 8, 10, 12]
print(binary_search(li, 6))

插值算法的中间位置计算时，对中间位置的计算有可能多次计算的结果是一样的，此时可以认为查找失败。

插值算法的性能介于线性查找和二分查找之间。

当数列中数字较多且分布又比较均匀时，插值查找算法的平均性能比折半查找要好的多。如果数列中数据分布非常不均匀，此种情况下插值算法并不是最好的选择。

4. 分块查找

分块查找

索引

分块查找

索引查找

现有原始数列

nums=[5,1,9,11,23,16,12,18,24,32,29,25]

11

**第

1

分块查找

最大值

最小值

按块有序

分块查找

**第

2

索引表

索引表

2

最大值数字

起始地址

索引表

**第

3

索引表

29

索引表

29

编码实现分块查找：

先编码实现根据分块数量、创建索引表，这里使用

二维列表

'''
分块：建立索引表
参数：
nums 原始数列
blocks 块大小
'''
def create_index_table(nums, blocks):
# 索引表使用列表保存
index_table = []
# 每一块的数量
n = len(nums) // blocks
for i in range(0, len(nums), n):
# 索引表中的每一行记录
tmp_lst = []
# 最大值
tmp_lst.append(max(nums[i:i + n-1]))
# 起始地址
tmp_lst.append(i)
# 终止地址
tmp_lst.append(i + n - 1)
# 添加到索引表中
index_table.append(tmp_lst)
return index_table
'''
测试分块
'''
nums = [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25]
it = create_index_table(nums, 3)
print(it)
'''
输出结果：
[[11, 0, 3], [23, 4, 7], [32, 8, 11]]
'''

代码执行后，输出结果和分析的结果一样。

分块查找的完整代码：

'''
分块：建立索引表
参数：
nums 原始数列
blocks 块大小
'''
def create_index_table(nums, blocks):
# 索引表使用列表保存
index_table = []
# 每一块的数量
n = len(nums) // blocks
for i in range(0, len(nums), n):
tmp_lst = []
tmp_lst.append(max(nums[i:i + n - 1]))
tmp_lst.append(i)
tmp_lst.append(i + n - 1)
index_table.append(tmp_lst)
return index_table

'''
使用线性查找算法在对应的块中查找
'''
def lind_find(nums, start, end):
for i in range(start, end):
if key == nums[i]:
return i
break
return -1

'''
测试分块
'''
nums = [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25]
key = 16
# 索引表
it = create_index_table(nums, 3)
# 索引表的记录编号
pos = -1
# 在索引表中查询
for n in range(len(it) - 1):
# 是不是在第一块中
if key <= it[0][0]:
pos = 0
# 其它块中
if it
[0] < key <= it[n + 1][0]:
pos = n + 1
break
if pos == -1:
print("{0} 在 {1} 数列中不存在".format(key, nums))
else:
idx = lind_find(nums, it[pos][1], it[pos][2] + 1)
if idx != -1:
print("{0} 在 {1} 数列的 {2} 位置".format(key, nums, idx))
else:
print("{0} 在 {1} 数列中不存在".format(key, nums))
'''
输出结果
16 在 [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25] 数列的第 5 位置
'''

分块查找

块排序

分块查找

索引表

5. 总结

本文讲解了

线性

二分

插值

分块

树表查找

哈希查找

分块算法

线性查找

插值查找

算法没有固定模式，如果学会了

二分查找