二分查找法_常见的非线性结构查找算法有哪些

搜索问题：
1 线性结构： 如果有序，可以用二分查找，如果无序要么暴力遍历复杂度O(N)要么先建立二叉搜索树, 然后再查找，此时查找的复杂度是O(H)，H为树高度

2 非线性结构，也就是树或者图：深度优先搜索，时间复杂度O(N), 可用栈代替；广度优先搜索，时间复杂度O(N), 可用队列代替。

二分查找：
由于每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是O（logN） 。二分查找的条件是查找范围不为空，即left<=right 。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left = 0 
        right = len(nums) - 1 
        while left <= right:
            mid = (right + left) // 2
            mid_val = nums[mid]
            if target > mid_val:
                left = mid + 1 
            elif target < mid_val:
                right = mid - 1 
            else:
                return mid 
        return -1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 在[start,end]中找是否存在target
def find(start, end, target):
    left = start
    right = end
    while left <= right:
        mid = (left + right) // 2
        if mid < target:
            left = mid + 1
        elif mid > target:
            right = mid - 1
        else:
            return mid
    return

print(find(-2, 6, -2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

当需要找到排序好的序列dn里面，小于某个target的后一位数的时候

def bisection_search(dn, target):
    l, r = 0, len(dn) - 1
    while l <= r:
        mid = (l + r) // 2
        if dn[mid] >= target:
            loc = mid
            r = mid - 1
        else:
            l = mid + 1
    return loc
1
2
3
4
5
6
7
8
9
10

输入[1,1,3], target=1, 结果是0

当需要找到排序好的序列dn里面，小于等于某个target的后一位数的时候

def bisection_search(dn, target):
    l, r = 0, len(dn) - 1
    while l < r:
        mid = (l + r) // 2
        if dn[mid] <= target:
            l = mid + 1
        else:
            r = mid
    return l
1
2
3
4
5
6
7
8
9

输入[1,1,3], target=1, 结果是2