二分查找法_7.用二分搜索算法在一个有序序列a1:n]中查找某指定元素x是否存在。在查找的过

二分搜索是一种在有序数组中查找某一特定元素的搜索算法。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

使用条件：
1、必须采用顺序存储结构。
2、必须按关键字大小有序排列。

二分查找，非递归（Java）

public static void main(String[] args) {
        int[] num={1,2,3,3,4,5,7,8,11,18,22,22};
        int n=5;
        int index=-1;

        int left=0;
        int right=num.length-1;
        int mid=(left+right)/2;
        while(left<=right) {
            if(num[mid]==n) {
                index=mid;
                break;
            // n大于中间元素，需要去右边找，查找范围变成 [mid+1, right]
            }else if(n>num[mid]) {
                left=mid+1;
            }else {
                right=mid-1;
            }
            mid=(left+right)/2;
        }
        if(index==-1) {
            System.out.println("你输入的数字不存在。");
        }else {
            System.out.println("数字"+n+"存在，是第"+(index+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
25
26

二分查找，递归（Java）

package com.guo;
public class Test {
    public static void main(String[] args) {
        int[] num={1,2,3,3,4,5,7,8,11,18,22,22};
        int n=5;
        int index=binarySearch(num,0,num.length-1, n);
        if(index==-1) {
            System.out.println("你输入的数字不存在。");
        }else {
            System.out.println("数字"+n+"存在，是第"+(index+1)+"个");
        }

    }

    public static int binarySearch(int[] arr,int left, int right, int n) {
        if (right >= left) {
            int mid = left + (right - left) / 2;
            if (n == arr[mid]) {
                return mid;
            }
            if (n > arr[mid]) {
                return binarySearch(arr, mid + 1, right, n);
            }
            if (n < arr[mid]) {
                return binarySearch(arr, left, mid - 1, n);
            }
        }
        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
25
26
27
28
29
30
31

二分查找，非递归（Python）

def binarySearch(arr, n):
    left, right = 0, len(arr) - 1
    while left<=right:
        mid = int(left + (right - left) / 2)
        if n==arr[mid]:
            return mid
        elif n>arr[mid]:
            left=mid+1
        else:
            right=mid-1
    else:
        return -1

# 测试数组
arr=[1,2,3,3,4,5,7,8,11,18,22,22]
# 需要查找的元素
n=22
index = binarySearch(arr,n)
if index == -1:
    print("元素不在数组中")
else:
    print("{}，在数组中的索引为:{}，即第{}个".format(n, index, index+1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

二分查找，递归（Python）

# 返回 x 在 arr 中的索引，如果不存在返回 -1 
# binarySearch（列表，上限，下限，需要查找的元素）
def binarySearch(arr, left, right, x):
    # 基本判断
    if right>= left:
        mid = int(left+ (right- left) / 2)
        # 元素整好的中间位置
        if arr[mid] == x:
            return mid
        # 元素小于中间位置的元素，只需要再比较左边的元素
        elif arr[mid] > x:
            return binarySearch(arr, left, mid - 1, x)
        # 元素大于中间位置的元素，只需要再比较右边的元素
        else:
            return binarySearch(arr, mid + 1, right, x)
    else:
        # 不存在
        return -1

# 测试数组
arr = [1, 2, 3, 3, 4, 5, 7, 8, 11, 18, 22, 22]
#arr.sort()   对列表arr排序，另一种等价写法是：arr=sorted(arr)
x = 11

# 函数调用
# 上限是0，下线是长度-1。代表对列表进行全局查找
result = binarySearch(arr, 0, len(arr) - 1, x)
if result != -1:
    print("{}在数组中的索引为:{}".format(x,result))
else:
    print("元素不在数组中")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31