查找算法：折半查找

话不多说，直接上代码：

package com.example.demo.study.search;

import com.example.demo.study.CommonService;
import com.example.demo.study.QuickSort;
import org.junit.Test;
import org.springframework.stereotype.Service;

@Service
public class DichotomySearch
{
//    @Autowired
//    private QuickSort quickSort;

    @Test
    public void testSearch()
    {
        QuickSort quickSort = new QuickSort();
        int[] a = {5, 8, 7, 28, 96, 4 , 7, 0, 3};
        quickSort.quickSort(a, 0, a.length-1);
        CommonService.printArray(a);
        System.out.println();
        search(a, 28);
    }

    /**
     * 二分查找法
     */
    public void search(int[] a, int src)
    {
        int start = 0;
        int end = a.length - 1;
        int i = 0;
        int n = 0;
        int position = -1;
        while (start < end)
        {
            n ++;
            int mid = (start + end) / 2;
            if (src > a[mid]) // 如果待查找值比中间值大，说明在数组右侧，则抛弃左边，从右边开始查找
            {
                start = mid + 1;
            }
            else if (src < a[mid])  // 如果待查找值比中间值小，说明在数组左侧，则抛弃右边，从左边查找
            {
                end = mid - 1;
            }
            else
            {
                position = mid;
                System.out.println(src + " position in a is " + mid);
                break;
            }
        }
        System.out.println("一共查询了 " + n + " 次");
        if (position == -1)
        {
            System.out.println("未找到查询元素：" + src);
        }
    }
}

算法思想：

首先将查找序列分成2半，确定可在哪一半，在确定的部分继续折半，直到找到该元素，或者查不到元素。

时间复杂度：

折半查找法要求查找的序列是有序序列，上面代码中以升序为例。每次减少一半序列，其时间复杂度为O（㏒碓数㏒2n）,也就是2的对数级。