递归和非递归的方式写二分查找有什么区别

递归和非递归的方式写二分查找有什么区别

前言：结论就是非递归比递归好用，既节省电脑的资源，写起来也方便

递归：

递归的二分查找方法，会调用一系列函数，并且会涉及到返回中的参数传递和返回值的额外开销，在一些嵌套层数深的算法中，递归会力不从心，空间上会以内存崩溃而告终。
但是递归也是有优势的，递归的代码的可读性强，程序员也容易进行编程。

非递归

非递归的二分查找一般就需要使用循环了，循环一般情况下会难以理解，而且要编写出循环实现功能也更加困难，不利于代码的可读性和代码的编写。但是循环的效率高，执行次数只会根据循环次数的增加而增加，不会有额外的开销。
总结：在二分查找中，由于循环方法容易写，也容易理解，用非递归好一点
以下是可以找出有序数组中所有符合目标的数，如目标数为12，则可以找出所有的12

非递归代码实现

package cn.ycl.BinarySearch;

import java.util.ArrayList;
import java.util.List;

//非递归方式进行二分查找
public class BinarySearchWithoutRecursion {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
int arr[]= {1,12,12,13,24,35,46,77,99};
List<Integer> searchWithoutSecursion = searchWithoutSecursion(arr, 77);
for (Integer integer : searchWithoutSecursion) {
	System.out.println(integer);
}
	}
	public static List<Integer> searchWithoutSecursion(int arr[] , int target) {
		int left=0;
		int right=arr.length-1;
		while (left<=right) {
			int mid=(left+right)/2;
			if (arr[mid]<target) {
				left=mid+1;
			}else if (arr[mid]>target) {
				right=mid-1;
			}else {
			
				List<Integer> list=new ArrayList<Integer>();
				list.add(mid);
				int temp=mid-1;
				//继续向左扫描
				while (true) {
					if (temp<0 || arr[temp] !=target) {
						break;
					}
					list.add(temp);
					temp-=1;
				}
				//继续向右扫描
				temp=mid+1;
				while (true) {
					if (temp>arr.length-1 || arr[temp]!=target) {
						break;
					}	
					list.add(temp);
					temp+=1;
				}
			return list;
			}
		}
		return null;
		
	}
}

递归代码实现

package cn.ycl.BinarySearch;
import java.util.ArrayList;
import java.util.List;
public class BinarySearchWithRecursion {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[] = { 1, 4, 7, 9, 12, 12, 90, 98 };
		List<Integer> binarySearchWithRecursion = binarySearchWithRecursion(arr, 0, arr.length, 12);
		for (Integer integer : binarySearchWithRecursion) {
			System.out.println(integer);
		}
	}
	public static List<Integer> binarySearchWithRecursion(int arr[], int left, int right, int target) {
		if (left > right) {
			return null;
		}
		int mid = (left + right) / 2;
		if (arr[mid] > target) {
			right = mid - 1;
			return binarySearchWithRecursion(arr, left, right, target);
		} else if (arr[mid] < target) {
			left = mid + 1;
			return binarySearchWithRecursion(arr, left, right, target);
		} else {
			List<Integer> list = new ArrayList<Integer>();
			list.add(mid);
			int temp = mid - 1;
			// 继续向左扫描
			while (true) {
				if (temp < 0 || arr[temp] != target) {
					break;
				}
				list.add(temp);
				temp--;
			}
			// 继续向右扫描
			int temp2 = mid + 1;
			while (true) {
				if (temp2 > arr.length - 1 || arr[temp2] != target) {
					break;
				}
				list.add(temp2);
				temp2++;
			}
			return list;
		}
	}
}