二分法查找
基本介绍
算法：二分法查找适用于数据量较大时，但是数据需要先排好顺序。
主要思想是：（设查找的数组区间为array[low, high]）
- 确定该区间的中间位置K
- 将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]b.array[k]<T 类似上面查找区间为array[k+1,……，high]。
时间复杂度为: O(log2n)。
代码实现
非递归查找单个值
/**
* 非递归的二分法查找
*
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param target 待查找的值
* @return 返回待查找值的下标，若未找到返回-1
*/
public static int binarySearchNoRecursion(int[] arr, int target) {
int left = 0;//左角标
int right = arr.length - 1;//右角标
int mid;//中间值
while (left <= right) {
mid = (left + right) / 2;
if (target < arr[mid]) {
right = mid - 1;
} else if (target > arr[mid]) {
left = mid + 1;
} else {
return mid;
}
}
return -1;
}
非递归查找所有符合条件的值
/**
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param target 待查找的值
* @return 返回待查找值的集合，若未找到返回null
*/
public static List<Integer> binarySearchAllNoRecursion(int[] arr, int target) {
int left = 0;//左角标
int right = arr.length - 1;//右角标
int mid;
while (left <= right) {
mid = (left + right) / 2;
if (target < arr[mid]) {
right = mid - 1;
} else if (target > arr[mid]) {
left = mid + 1;
} else {
List<Integer> list = new ArrayList<>();
list.add(mid);
int temp;//使用临时变量记录当前坐标
//向左查找
temp = mid - 1;
while (temp >= 0 && arr[temp] == target) {
list.add(temp--);
}
//向右查找
temp = mid + 1;
while (temp < arr.length && arr[temp] == target) {
list.add(temp++);
}
return list;
}
}
return null;
}
递归查找单个值
/**
* 递归的二分法查找
*
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param left 左角标
* @param right 右角标
* @param target 待查找的值
* @return 返回待查找值的下标，若未找到返回-1
*/
public static int binarySearchByRecursion(int[] arr, int left, int right, int target) {
if (left > right) {
return -1;
}
int mid = (left + right) / 2;
if (target < arr[mid]) {
return binarySearchByRecursion(arr, left, mid - 1, target);
} else if (target > arr[mid]) {
return binarySearchByRecursion(arr, mid + 1, right, target);
} else {
return mid;
}
}
递归查找所有符合条件的值
/**
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param left 左角标
* @param right 右角标
* @param target 待查找的值
* @return 返回待查找值的集合，若未找到返回null
*/
public static List<Integer> binarySearchAllByRecursion(int[] arr, int left, int right, int target) {
if (left > right) {
return null;
}
int mid = (left + right) / 2;
if (target < arr[mid]) {
return binarySearchAllByRecursion(arr, left, mid - 1, target);
} else if (target > arr[mid]) {
return binarySearchAllByRecursion(arr, mid + 1, right, target);
} else {
List<Integer> list = new ArrayList<>();
list.add(mid);
int temp;//临界变量记录mid值
//向左判断
temp = mid - 1;
while (temp >= 0 && target == arr[temp]) {
list.add(temp--);
}
//向右判断
temp = mid + 1;
while (temp < arr.length && target == arr[temp]) {
list.add(temp++);
}
return list;
}
}
代码汇总
package com.athome.binarysearch;
import java.util.ArrayList;
import java.util.List;
/**
* Description:
* Author:江洋大盗
* Date:2021/1/17 9:11
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {
1, 5, 6, 9, 9, 9, 9, 10, 24, 39, 42};
System.out.println("非递归查找10:" + binarySearchNoRecursion(arr, 10));
List<Integer> list = binarySearchAllNoRecursion(arr, 9);
System.out.println("非递归查找所有9:" + list);
System.out.println("递归查找10:" + binarySearchByRecursion(arr, 0, arr.length - 1, 10));
List<Integer> list1 = binarySearchAllByRecursion(arr, 0, arr.length - 1, 9);
System.out.println("递归查找所有9:" + list1);
}
/**
* 非递归的二分法查找
*
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param target 待查找的值
* @return 返回待查找值的下标，若未找到返回-1
*/
public static int binarySearchNoRecursion(int[] arr, int target) {
int left = 0;//左角标
int right = arr.length - 1;//右角标
int mid;//中间值
while (left <= right) {
mid = (left + right) / 2;
if (target < arr[mid]) {
right = mid - 1;
} else if (target > arr[mid]) {
left = mid + 1;
} else {
return mid;
}
}
return -1;
}
/**
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param target 待查找的值
* @return 返回待查找值的集合，若未找到返回null
*/
public static List<Integer> binarySearchAllNoRecursion(int[] arr, int target) {
int left = 0;//左角标
int right = arr.length - 1;//右角标
int mid;
while (left <= right) {
mid = (left + right) / 2;
if (target < arr[mid]) {
right = mid - 1;
} else if (target > arr[mid]) {
left = mid + 1;
} else {
List<Integer> list = new ArrayList<>();
list.add(mid);
int temp;//使用临时变量记录当前坐标
//向左查找
temp = mid - 1;
while (temp >= 0 && arr[temp] == target) {
list.add(temp--);
}
//向右查找
temp = mid + 1;
while (temp < arr.length && arr[temp] == target) {
list.add(temp++);
}
return list;
}
}
return null;
}
/**
* 递归的二分法查找
*
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param left 左角标
* @param right 右角标
* @param target 待查找的值
* @return 返回待查找值的下标，若未找到返回-1
*/
public static int binarySearchByRecursion(int[] arr, int left, int right, int target) {
if (left > right) {
return -1;
}
int mid = (left + right) / 2;
if (target < arr[mid]) {
return binarySearchByRecursion(arr, left, mid - 1, target);
} else if (target > arr[mid]) {
return binarySearchByRecursion(arr, mid + 1, right, target);
} else {
return mid;
}
}
/**
* @param arr 待查找的数组，此处数组默认按照从小到大排列
* @param left 左角标
* @param right 右角标
* @param target 待查找的值
* @return 返回待查找值的集合，若未找到返回null
*/
public static List<Integer> binarySearchAllByRecursion(int[] arr, int left, int right, int target) {
if (left > right) {
return null;
}
int mid = (left + right) / 2;
if (target < arr[mid]) {
return binarySearchAllByRecursion(arr, left, mid - 1, target);
} else if (target > arr[mid]) {
return binarySearchAllByRecursion(arr, mid + 1, right, target);
} else {
List<Integer> list = new ArrayList<>();
list.add(mid);
int temp;//临界变量记录mid值
//向左判断
temp = mid - 1;
while (temp >= 0 && target == arr[temp]) {
list.add(temp--);
}
//向右判断
temp = mid + 1;
while (temp < arr.length && target == arr[temp]) {
list.add(temp++);
}
return list;
}
}
}
测试结果：
结语
只要能收获甜蜜，荆棘丛中也有蜜蜂忙碌的身影，未来的你一定会感谢现在努力的自己。