二份查找算法(递归与非递归)
用此算法的前提是该研究对象是有序数组
一、非递归
思路分析:
-
实现确定该数组的中间的下标
-
然后让需要查找的数findVal和arr[mid]比较
2.1 findVal>arr[mid],说明你要查找的数在mid的右边,因此需要递归向右查找
2.2 findVal<arr[mid],说明你查找的数在mid的左边,因此需要递归向左查找
2.3 finfVal==arr[mid],就返回
什么时候结束:
- 找到就结束递归
2)递归完整个数组,仍然没有找到findVal,也需要结束递归当left > right就需要退出
代码实现:
package 基础算法.二分查找算法;
public class BinarySearch {
public static void main(String[] args) {
int arr[] = {1,8,10,89,1000,1234};
int resIndex = binarySearch(arr,0,arr.length-1,1234);
System.out.println(resIndex);
}
//二分算法(递归)
/**
*
* @param arr
* @param left
* @param right
* @param findVal
* @return 如果找到就返回下标,没有找到就返回-1
*/
public static int binarySearch(int[] arr,int left,int right,int findVal){
//当left>right时,结束递归
if (left > right){
return -1;
}
int mid =(left+right)/2;
int midVal = arr[mid];
if(findVal > midVal){//向右递归
return binarySearch(arr, mid+1, right, findVal);
}
else if (findVal < midVal){//向左递归
return binarySearch(arr, left, mid-1, findVal);
}
else {
return mid;
}
}
}
上述代码存在没有考虑findVal对应arr数组中的两个或者多个,只会现实出现的第一个
改进思路分析:
- 在找的mid索引值,不要立马返回
- 向mid索引值得左边扫描,将所有满足的值的元素下标加到集合ArrayList
- 向mid索引的右边扫描,将满足的所有的值的下标,加入到集合ArrayList
- 将ArrayList返回
改进代码:
package 基础算法.二分查找算法;
import java.util.ArrayList;
import java.util.List;
public class BinarySearch {
public static void main(String[] args) {
int arr[] = {1,8,10,89,1000,1000,1000,500,1000,1234};
List<Integer> resIndexList =binarySearch2(arr,0,arr.length-1,1000);
System.out.println("resIndexList="+resIndexList);
}
//二分查找(递归改进)
/**
*
* @param arr 数组
* @param left 左边索引
* @param right 右边索引
* @param findVal 找的值
* @return 如果找到返回ArrayList集合,没有找到返回[]
*/
public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal){
//当left>right时,结束递归
if (left > right){
return new ArrayList<Integer>();
}
int mid =(left+right)/2;
int midVal = arr[mid];
if(findVal > midVal){//向右递归
return binarySearch2(arr, mid+1, right, findVal);
}
else if (findVal < midVal){//向左递归
return binarySearch2(arr, left, mid-1, findVal);
}
else {
/*1. 在找的mid索引值,不要立马返回
2. 向mid索引值得左边扫描,将所有满足的值的元素下标加到集合ArrayList
3. 向mid索引的右边扫描,将满足的所有的值的下标,加入到集合ArrayList
4. 将ArrayList返回*/
ArrayList<Integer> resIndexlist = new ArrayList<Integer>();
//向mid索引值左边扫描,将满足的所有值得元素下标,加入集合ArrayList
int temp = mid -1;
while(true){
if (temp<0){//退出
break;
}
//如果找到temp放入到resIndexlist
if (arr[temp]==findVal){
resIndexlist.add(temp);
}
temp -=1;//temp左移
}
//把找的值添加到ArrayList中去
resIndexlist.add(mid);
//向mid索引值右边扫描,将满足的所有值得元素下标,加入集合ArrayList
temp = mid +1;
while(true){
if (temp>arr.length-1){//退出
break;
}
//如果找到temp放入到resIndexlist
if (arr[temp]==findVal){
resIndexlist.add(temp);
}
temp +=1;//temp右移
}
return resIndexlist;
}
}
}
结果:
resIndexList=[4, 5, 6, 8]
二、递归
思路分析:
- 找的数比我中间的要小,则向左边查找,找的数比我中间的数要大则向右边查找(前提是升序)
- 不断的重复第一步直至中间值就是自己
代码实现:
package 基础算法.二分查找算法;
public class BinarySearchNoRecur {
public static void main(String[] args) {
int [] arr ={1,3,8,10,11,67,100};
int index = binarySearch(arr,-8);
System.out.println("index="+index);
}
//二分算法的非递归
/**
*
* @param arr
* @param target
* @return 返回对应的下标,-1表示没有找到
*/
public static int binarySearch(int[] arr,int target){
int left = 0;
int right = arr.length-1;
while(left <= right){//说明可以继续查找
int mid = (left+right)/2;
if(arr[mid] == target){
return mid;
}
else if(arr[mid]>target){
right =mid - 1;//需要向左边查找
}
else {
left = mid +1;//需要向右边查找
}
}
return -1;
}
}