活动地址：CSDN21天学习挑战赛

算法 三分学，七分练，每天进步一点点。

1. 概念

折半查找又称二分查找，是一种在有序数组中查找某一个特定元素的搜索算法，是一种效率较高的查找方法，但是，折半查找适用于不经常变动而查找频繁的有序列表。折半查找的优缺点如下：

• 优点
  比较次数少，查找速度快，平均性能好。
• 缺点：
  前提要求待查表为有序表
  算法思想：
  首先确定好low、mid、high 3个位置，一般情况下中间位置mid = (low + high)/2。
  （1）搜索过程从中间元素开始，若中间元素刚好等于所要查找的元素则返回查找元素下标，查找结束。
  （2）若中间元素小于所要查找的元素，则查找元素存在于中间元素的右边，并重新确定low的位置，low = mid+1
  （3）若中间元素大于所要查找的元素，则查找元素存在于中间元素的左边，并重新确定high的位置，high = mid -1
  （4）若low>high,则表中并没有所要查找的元素

2. 伪代码

low = 1;
high = a.length; //置查找区间初值
while (low <= high)
{
    mid = (low + high) / 2;
    if (key == a[mid])
        return mid; //找到待查元素
    else if (key < a.[mid])
        high = mid - 1; 
    else
        low = mid + l; 
    return -1;
1
2
3
4
5
6
7
8
9
10
11
12

3. 代码实现

给大家分享力扣中第704题吧.
题目：

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 
nums 中的 target，如果目标值存在返回下标，否则返回 -1。
1
2

示例1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
1
2

3.1 Java版本

public class BinarySearch {
	public static void main(String[] args){
		int[] nums = [-1,0,3,5,9,12];
		int target = 9;
		int result = search(nums,target);
		System.out.println(result);
	
	}
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = (right - left) / 2 + left;
            int num = nums[mid];
            if (num == target) {
                return mid;
            } else if (num > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.2 Python版本

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

4. 算法效率分析

4.1 时间复杂度

最好的情况：第一次查找中间元素就是所要查找的元素，时间复杂度为O(1)
最坏的情况：最后一次才查找到元素，时间复杂度为：以2为底，N的对数。
所以，平均时间复杂度为：以2为底，N的对数（O(logn)）

4.2 空间复杂度

在算法中，只需要几个额外的变量来记录关键信息，所以，空间复杂度为O(1)。

坚持每天练题，一定会有不少的收获，加油。