【C】折半（二分）查找

目录

1. 基本思想

1.1 算法分析

2. 算法实现

3. 源代码

3.1 Makefile

3.2 binary_search.c​​​​​​​

折半查找也称为二分查找，是一种在 有序数组 中 查找某一特定元素 的搜索算法。其优点是查找速度快，缺点是所要查找的数据必须在有序序列中。

1. 基本思想

假设有一个按照升序排列的数组 arr，在该数组中查找元素 key。

• 首先找出该数组中最中间的元素
• 然后将最中间的元素 arr[mid] 与所要查找的元素 key 进行比较
  • 如果相等则返回该元素的下标 mid
  • 如果 arr[mid] > key，那么在 mid 左边的区间去查找 key
  • 如果 arr[mid] < key ，那么在 mid 右边的区间中去查找 key。
• 重复上述步骤，直到找到元素 key 为止，假如没有找到，则返回失败。

1.1 算法分析

假设有 n 个元素，经过第一次查找后，查找区间缩短为 n / 2，经过第二次查找后，查找区间缩短为 n / 4，…… 那么经过 k 次查找后，查找区间变为 n / 2^k（ps: n 除上 2 的 k 次方）。不难发现，k 其实就是循环次数，那么最终找到元素 key 时，n / 2^k = 1（ps: 这里等于 1 就表示找到了元素 key），因此可以得出最坏情况下该算法的时间复杂度为 O(log2n)（ps: log2n 表示以 2 为底，n 的对数）。
浅析时间复杂度和空间复杂度https://blog.csdn.net/sustzc/article/details/80612758

2. 算法实现

• 设置初始查找值：left = 0，right = len - 1
• 取中间位置 mid = (left & right) + ((left ^ right) >> 1)
• 比较 key 与 arr[mid] 的大小
  • 若 arr[mid] == key，则表示查找成功，返回该元素在数组 arr 中的下标 mid，
  • 若 arr[mid] > key，则表示查找区间应该更新为 mid 左半区间，right = mid - 1
  • 若 arr[mid] < key，则表示查找区间应该更新为 mid 右半区间，left = mid + 1
• 重复上述步骤，如果还没有找到元素 key，则返回失败。

3. 源代码

3.1 Makefile

.PHONY: clean ALL

CC = gcc
CFLAGS = -g -Wall -DDEBUG
#EXTRA_FLAGS = -DUSE_GLIBC

SOURCE = $(wildcard ./*.c)
BIN = $(basename $(SOURCE))

ALL: $(BIN)
%: %.c
	$(CC) $(CFLAGS) $(EXTRA_FLAGS) $< -o $@

clean:
	-rm -rf $(BIN)

3.2 binary_search.c

#include <stdio.h>

#ifdef USE_GLIBC
#include <stdlib.h>
#endif /// USE_GLIBC

#define ARRAY_SIZE(ARRAY) ((sizeof(ARRAY)) / (sizeof(ARRAY[0])))

void print_array(const char *arr_name,
                 int arr[],
                 int len)
{
    printf("%s: ", arr_name);

    int i = 0;
    for (; i < len; ++i) {
        printf("%-4d", arr[i]);
    }

    printf("\n");
}

int binary_search(int arr[], int len, int key)
{
    int left = 0;
    int right = len - 1;
    int mid = 0;

    while (left <= right) {
        mid = (left & right) + ((left ^ right) >> 1);
        if (arr[mid] == key) {
            return mid;
        } else if (arr[mid] > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return -1;
}

#ifdef USE_GLIBC
int cmp_int_func(const void *a, const void *b)
{
   return *(int *)a - *(int *)b;
}
#endif /// USE_GLIBC

void test_binary_search(const char *arr_name,
                        int arr[],
                        int len,
                        int key)
{
    printf("\tin %s, ", arr_name);

#ifndef USE_GLIBC
    printf("use custom function, ");

    int ret = binary_search(arr, len, key);
    if (-1 == ret) {
        printf("not found %d\n", key);
    } else {
        printf("found %d, index = %d\n", key, ret);
    }
#else
    printf("use glibc function, ");

    int *found = (int *)bsearch(&key, arr, len, sizeof(int), cmp_int_func);
    if (NULL == found) {
        printf("not found %d\n", key);
    } else {
        printf("found %d\n", *found);
    }
#endif /// USE_GLIBC
}

void test()
{
    int arr_one[] = {1, 2, 3, 4, 5};
    int arr_two[] = {2, 3, 5, 7, 9, 10};
    int arr_three[] = {1, 2, 3, 5, 7, 9, 10};

    int len_one = ARRAY_SIZE(arr_one);
    int len_two = ARRAY_SIZE(arr_two);
    int len_three = ARRAY_SIZE(arr_three);

    printf("array list:\n");
    print_array("\tone array", arr_one, len_one);
    print_array("\ttwo array", arr_two, len_two);
    print_array("\tthree array", arr_three, len_three);

    printf("call binary search:\n");

    test_binary_search("arr_one", arr_one, len_one, 3);
    test_binary_search("arr_two", arr_two, len_two, 6);
    test_binary_search("arr_three", arr_three, len_three, 5);
}

int main(void)
{
    test();

    return 0;
}