拼多多算法面试题-二分查找

题目：给定一个有序数列和target值，判断target是否在序列中，并返回index，序列中的值可能重复，需要返回最大的index值

解法：二分查找

python版代码

1.非递归算法

    def binary_search(lis, nun):
        left = 0
        right = len(lis) - 1
        while left <= right:   #循环条件
            mid = (left + right) // 2   #获取中间位置，数字的索引（序列前提是有序的）
            if num < lis[mid]:  #如果查询数字比中间数字小，那就去二分后的左边找，
                right = mid - 1   #来到左边后，需要将右变的边界换为mid-1
            elif num > lis[mid]:   #如果查询数字比中间数字大，那么去二分后的右边找
                left = mid + 1    #来到右边后，需要将左边的边界换为mid+1
            else:
                return mid  #如果查询数字刚好为中间值，返回该值得索引
        return -1  #如果循环结束，左边大于了右边，代表没有找到

    lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
    print(lis)
    lis.sort()
    print(lis)
    while 1:
        num = int(input('输入要查找的数：'))
        res = binary_search(lis, num)
        print(res)
        if res == -1:
            print('未找到！')
        else:
            print('找到！')

2.递归算法

    def binary_search(lis, left, right, num):

        if left > right: #递归结束条件
            return -1
        mid = (left + right) // 2
        if num < lis[mid]:
            right = mid -1
        elif num > lis[mid]:
            left = mid + 1
        else:
            return mid
        return binary_search(lis, left, right, num)
        #这里之所以会有return是因为必须要接收值，不然返回None
        #回溯到最后一层的时候，如果没有return，那么将会返回None

    lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
    print(lis)
    lis.sort()
    print(lis)
    while 1:
        num = int(input('输入要查找的数：'))
        res = binary_search(lis, 0, len(lis)-1,num)
        print(res)
        if res == -1:
            print('未找到！')
        else:
            print('找到！')

C++版本

迭代法实现：
#include<iostream>
using namespace std;
int binary_search(int arr[], int low, int high, int key)
{
	//查找某元素是否存在于数组中 若存在，则返回下标；否则返回-1
	while (low <= high) {
		// 检查key是否在中间
		int mid = low + (high - low) / 2;
		if (arr[mid] == key)
			return mid;
		// 如果x大于arr[mid] 则low = mid+1;否则high=mid-1
		if (arr[mid] < key)
			low = mid + 1;
		else
			high = mid - 1;
	}
	return -1;
}
int main()
{
	int arr[] = { 2, 3, 4, 10, 40 };
	int x = 10;
	int n = sizeof(arr) / sizeof(arr[0]);
	int result = binary_search(arr, 0, n - 1, x);
	(result == -1) ? cout << "Element is not present in array"
		: cout << "Element is present at index " << result;
	return 0;
}

递归法实现：
# include<iostream>
using namespace std;
int binary_search(int arr[],int low , int high, int key)
{
	""" 通过递归二分查找 查找元素"""
	if(low<=high){
		int mid = low + (high-low)/2;
		//若元素在中间 
		if(arr[mid] == key)
			return mid;
		// 若元素比中间的数小 那么它只可能在左边的子数组中 则可另high = mid -1
		elif (arr[mid] > key)
			return binary_search(arr,low,mid-1,key);
        //否则 只可能在右边的子数组汇总 则可令low = mid+1
        return binary_search(arr,mid+1,high,key);  
	}
	// 该元素不在数组中
	return -1;
}
int main()
{
	int arr[] = { 2, 3, 4, 10, 40 };
	int x = 10;
	int n = sizeof(arr) / sizeof(arr[0]);
	int result = binary_search(arr, 0, n - 1, x);
	(result == -1) ? cout << "Element is not present in array"
		: cout << "Element is present at index " << result;
	return 0;
}