二分查找

/**
*
* @author SunnyMoon
*/

/**
* 概念介绍:
*
* 递归的二分查找: 想用最少的比较次数在一个有序的数组中找到一个给定的数据项。
*
* 非递归的二分查找：二分查找也可以用非递归的算法，但是分治算法通常要回到递归。分治算
* 法常常是一个方法，在这个方法中含有两个对自身的递归的调用。
*
* 分治算法：递归的二分查找是分治算法的一种实现方法。把一个是问题分成两个更小的问题，
* 并且解决它们。这个过程一直持续下去直到易于求解的基值情况，就不需再分了。
* 分治算法常常是一上方法，在这个方法中含有两个对自身的递归调用，分别对应于
* 问题的两个部分。在二分查找中，就有两个这样的调用，但是只有一个真的执行了
* （调用哪一个取决于关键字的值）。
* 递归的效率：调用一个方法会有一定的代价和开销。首先，控制必须须从当前位置转移到调用
* 方法的开始处。其次，传给这个方法的参数以及这个方法返回地址都要初压到一
* 个栈里，为的是方法能够访问参数以及知道返回值在存储在哪里，这个过程也称
* "保存现场"。递归方法的使用的本质是从概念上简化了问题，而不是因为它更有
* 效率。当使用递归的效率很低的时候，就可以考虑如果把递归转化成非递归。
*/
class OrdArray {

private long[] a;
private int nElems;

public OrdArray(int max) {
a = new long[max];
nElems = 0;
}

public int size() {
return nElems;
}

public int find(long searchKey) {
return recFind(searchKey, 0, nElems - 1);//调用递归方法
//return recFind2(searchKey, 0, nElems - 1);//调用非递归方法
}

public int recFind(long searchKey, int lowerBound, int upperBound) {//递归方法定义
int curIn = (lowerBound + upperBound) / 2;
if (a[curIn] == searchKey) {
return curIn;
} else if (lowerBound > upperBound) {
return nElems;
} else {
if (a[curIn] < searchKey) {
return recFind(searchKey, curIn + 1, upperBound);
} else {
return recFind(searchKey, lowerBound, curIn - 1);
}
}
}
public int recFind2(long searchKey, int lowerBound, int upperBound){//非递归方法定义
int curIn=0;

while(true){
curIn=(lowerBound+upperBound)/2;
if(a[curIn]==searchKey)
return curIn;
else if(lowerBound>upperBound)
return nElems;
else{
if(a[curIn]<searchKey){
lowerBound=curIn+1;
}
else{
upperBound=curIn-1;
}
}
}
}
public void insert(long value){
int j;
for(j=0; j<nElems; j++)
if(a[j]>value)
break;
for(int k=nElems; k>j; k--)
a[k]=a[k-1];
a[j]=value;
nElems++;
}
public void display(){
for(int j=0; j<nElems; j++){
System.out.println(a[j]+"");
}
}
}
class BinarySearchApp{
public static void main(String[] args){
int maxSize=100;
OrdArray arr=new OrdArray(maxSize);

arr.insert(72);
arr.insert(90);
arr.insert(45);
arr.insert(126);
arr.insert(54);
arr.insert(99);
arr.insert(144);
arr.insert(27);
arr.insert(135);
arr.insert(81);
arr.insert(18);
arr.insert(100);
arr.insert(9);
arr.insert(117);
arr.insert(63);
arr.insert(36);
arr.display();

int searchKey=100;
if(arr.find(searchKey) !=arr.size())
System.out.println("Found "+searchKey);
else
System.out.println("Can't find "+ searchKey);
}
}
/**
* 运行结果：
* 9
* 18
* 27
* 36
* 45
* 54
* 63
* 72
* 81
* 90
* 99
* 100
* 117
* 126
* 135
* 144
* Found 100
*/
/**
* 总结：
* 很多的数学问题都使用递归的方法解决，比如找两个数的最大公约数，求一个数的
* 乘方等等。如果有效率需求的时候，可以再考虑将递归转化成非递归。
*/