java的二分查找

『壹』 二分查找 為什麼 查找第一個數(7)是 會報異常:java.lang.StackOverflowError 各位大哥 看看下面代碼

.二分法，首先要求，必須是有序的，
然後是 關於查不到結果的判斷

如果 假設查找的是7，
依次查找的下標為 3，1，沒找到。。。
出現了一種情況： centerIndex > rightIndex 悲劇 這下好了，下面情況 你輸出一下 3個index你就知道咋回事兒了， 實際上是成了一個沒有出口 的遞歸運算， 必然會出現溢出棧的情況。。。。

『貳』 用二分法查找（折半查找）java

二分查找也稱折半查找（Binary Search），它是一種效率較高的查找方法。但是，折半查找要求線性表必須採用順序存儲結構，而且表中元素按關鍵字有序排列。

二分查找優缺點

優點是比較次數少，查找速度快，平均性能好；

其缺點是要求待查表為有序表，且插入刪除困難。

因此，折半查找方法適用於不經常變動而查找頻繁的有序列表。
使用條件：查找序列是順序結構，有序。

過程

首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查找關鍵字比較，如果兩者相等，則查找成功；否則利用中間位置記錄將表分成前、後兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找後一子表。重復以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。

利用循環的方式實現二分法查找

public class BinarySearch {
public static void main(String[] args) {
// 生成一個隨機數組 int[] array = suiji();
// 對隨機數組排序 Arrays.sort(array);
System.out.println("產生的隨機數組為： " + Arrays.toString(array));

System.out.println("要進行查找的值： ");
Scanner input = new Scanner(System.in);
// 進行查找的目標值 int aim = input.nextInt();

// 使用二分法查找 int index = binarySearch(array, aim);
System.out.println("查找的值的索引位置： " + index);

}

/** * 生成一個隨機數組 *
* @return 返回值，返回一個隨機數組 */
private static int[] suiji() {
// random.nextInt(n)+m 返回m到m+n-1之間的隨機數 int n = new Random().nextInt(6) + 5;
int[] array = new int[n];
// 循環遍歷為數組賦值 for (int i = 0; i < array.length; i++) {
array[i] = new Random().nextInt(100);
}
return array;
}

/** * 二分法查找 ---循環的方式實現 *
* @param array 要查找的數組 * @param aim 要查找的值 * @return 返回值，成功返回索引，失敗返回-1 */
private static int binarySearch(int[] array, int aim) {
// 數組最小索引值 int left = 0;
// 數組最大索引值 int right = array.length - 1;
int mid;
while (left <= right) {
mid = (left + right) / 2;
// 若查找數值比中間值小，則以整個查找范圍的前半部分作為新的查找范圍 if (aim < array[mid]) {
right = mid - 1;
// 若查找數值比中間值大，則以整個查找范圍的後半部分作為新的查找范圍 } else if (aim > array[mid]) {
left = mid + 1;
// 若查找數據與中間元素值正好相等，則放回中間元素值的索引 } else {
return mid;
}
}
return -1;
}}
運行結果演示：

總結：

遞歸相較於循環，代碼比較簡潔，但是時間和空間消耗比較大，效率低。在實際的學習與工作中，根據情況選擇使用。通常我們如果使用循環實現代碼只要不是太繁瑣都選擇循環的方式實現~

『叄』 java二分法查找的遞歸演算法怎麼實現

publicclass二分法遞歸查找{
	publicstaticvoidmain(String[]args){

		//定義數組,注意,二分查找數組必須是有序的數組!
		int[]arr={1,3,5,7,9,11,13,15,17};
		
		//接受查找後的返回值:索引值,如果沒有則是-1;
		//測試查找元素:9
		inta=binary(arr,9,0,arr.length-1);
		System.out.println("被查找數字索引位置在:"+a);
	}
	//參數列表依次為:被查找的數組,查找的數字,頭索引,尾索引!
	publicstaticintbinary(int[]arr,intkey,intstar,intend)//遞歸
	{
		//每次進來創建,中間索引值!
		intmid=(star+end)/2;
		//如果被查找數小於頭,或者尾,或者頭索引大於尾索引,則說明無該數,返回-1;
		if(key<arr[star]||key>arr[end]||star>end){
			return-1;
		}
		//如果中間值小於被查找數,則重新定義頭索引移至中間+1位置,篩選掉一半數字!
		if(arr[mid]<key){
			//開始遞歸!
			returnbinary(arr,key,mid+1,end);
			//否則如果中間值大於被查找數,則重新尾索引移至中間-1位置,篩選掉一半數字!
		}elseif(arr[mid]>key){
			//開始遞歸!
			returnbinary(arr,key,star,mid-1);
		}else{
			//否者就是找到了,返回該索引!
			returnmid;
		}
	}
}

『肆』 用Java語言編寫對整型數組進行二分查找的程序。

public class BinarySearchDemo {

public static void main(String[] args) {
int[] a = new int[]{1,5,7,9,11,18,23,48,69};
int point = new BinarySearchDemo().binarySearch(a, 23);

if(point == -1)
System.out.println("在數組中未查找到數23");
else
System.out.println("數字23是數組中第 " + (point + 1) + " 位數");

}

/**
* 二分法查找一個整數在整型數組中的位置
*
* 演算法思路：首先得到數組a的最小值和最大值的下標，分別是：low和high，接著求出值位於數組中間那個數的下標middle
* 然後再將這個middle對應的數組中的數和待查找的數num進行比較，如果相等，則表示已查找到，如果num < a[middle]
* 則說明num位於a[low]和a[middle]之間，於是將a[middle - 1]設為較大值，繼續求出此時對應的a[middle]，
* 再進行比較，其他情況可依次類推。一直到low=high，如果此時還沒有在數組a中查找到，則說明該數組a中沒有值num，返回-1
*
* @param a 給定的整型數組
* @param num 待查找的數 num
*
* @return 返回整數num在數組a中的位置下標，如果未查找到則返回-1
* */
public int binarySearch(int[] a,int num){
int low = 0;
int high = a.length - 1;

while(low <= high){
int middle = (low + high) / 2;
if(num == a[middle])
return middle;
else if(num < a[middle])
high = middle - 1;
else
low = middle + 1;
}

return -1;
}

}

程序基本上就是這樣了，其中注釋中有詳細的解釋說明

『伍』 JAVA二分查找

//*******二分查找，都注釋了，復制所有代碼，保存成QuickSortApp.java*************//
class ArrayIns
{
private long theArray[];
private int nElems;
//--------------------
public ArrayIns(int max){ //構造方法，初始化成員屬性。
theArray = new long[max];
nElems = 0;
}
//-----------------------
public void insert(long value){ //insert方法用於給數組賦扒虛塵值，並用nElems記錄數組元素的個數。
theArray[nElems] = value;
nElems++;
}
//----------------------------
public void display(){ //display方法用於顯示數組的所有元素到控制台。
System.out.println("A= ");
for(int j=0;j<nElems;j++)
System.out.print(theArray[j]+" ");
System.out.println("");
}
//------------------------------
public void quickSort(){ //ArrayIns對象調用quickSort方法可以為其成員屬性theArray數組中的元素排序（從小到大）
recQuickSort(0,nElems-1); //調用recQuickSort方法開始排序，初始范圍從第一個到最後一個開始。
}
//-------------------------------
private void recQuickSort(int left,int right){ //recQuickSort方法進行數組元素的排序。left,right表示排序的范圍.
if(right-left <= 0)
return; //如果right小於left,則第歸返回。此處是第歸的出口。
else {
long pivot = theArray[right]; //每次把排序范圍中的最後一個數作為排序時的參照數。
int partition = partitionIt(left,right,pivot); //調用prititionIt方法，參數列表中指明排序的范圍和參照數，並將方法的返回值賦給pritition變數(用來指明下一次排序時的范圍。)
//System.out.print(" "+1); //數字1代表第一次第譽余歸的調用。
recQuickSort(left,partition-1); //第歸調用本方法，排序右范圍由partition-1來決定。
//System.out.print(" "+2); //數字2代表第二次第歸的調用。
recQuickSort(partition+1,right); //第歸調用本方法，排序左范圍由partition-1來決定。
}
}
//-----------------------------------
private int partitionIt(int left,int right,long pivot){ //partitionIt方法完成left和right范圍內元素間排序的具體過程。
int leftPtr = left-1; //leftPrt表示左標識位，從left-1開始。
int rightPtr = right; //rightPrt表示右表識位，到right。 while(true){//永真循環。
while(theArray[++leftPtr] < pivot); // 空循環，從leftPrt開始往rightPrt方向開始找一個比pivot大的數,用leftPtr記錄元素的位置。
while(rightPtr>0 && theArray[--rightPtr]>pivot);//空循環，從春禪rightPrt往leftPrt方向開始找一個比pivot小的數，用rightPrt記錄元素的位置,並且rightPtr>0會保證不會數組越界。
if(leftPtr >= rightPtr) //永真循環的出口，表示本次排序結束。
break;//跳出循環。
else
swap(leftPtr,rightPtr);//將leftPtr和rightPtr所在位置的元素進行交換。
}
swap(leftPtr,right); //調用swap方法。
return leftPtr; //將leftPtr返回到本方法被調用的位置。用來指明下一次排序時的范圍.
}
//---------------------------------------------
private void swap(int dex1,int dex2){ //swap方法用來將數組中的兩個元素進行交換，dex1和dex2分別表示兩個數組元素的位置。
long temp = theArray[dex1]; //temp變數作為兩個數組元素交換時的臨時中轉變數。
theArray[dex1] = theArray[dex2];
theArray[dex2] = temp;
}
}//////////////////////////////////////////////////////////////////////////////////////class QuickSortApp
{
public static void main(String[] args)
{
int maxSize = 10; //定義變數maxSize，並賦初值10.
ArrayIns arr;
arr = new ArrayIns(maxSize);//創建ArrayIns類的對象arr for(int j=0;j<maxSize;j++){
long n = (int)(java.lang.Math.random()*99);//產生隨機數。
arr.insert(n); //用insert方法為arr中的成員數組變數賦值。
}
arr.display(); //用display方法顯示arr中成員變數數組中的所有元素。
arr.quickSort(); //用quickSort方法為arr成員變數數組中的元素按從小到大排序。
arr.display(); //顯示。
}
}