java二分查找法

㈠ java二分查找法，我寫的東西不運行

public void search(int left, int right, int target, int[] arr)
throws Exception {
if (left > right) {// 左右交叉了，沒找到返回
System.out.println("沒結果！");
return;
}
int mid = (left + right) / 2;
int val = arr[mid];
if (target == val) {// 目標值找到返回
System.out.println("下標為：" + mid);
return;
}
if (target < val)// 目標值比中間值小，往左側搜
search(left, mid - 1, target, arr);
else if (target > val)// 目標值比中間值大,往右側搜
search(mid + 1, right, target, arr);
}

㈡ 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二分法查找。

public class BinarySearch {
/**
* 二分查找
* 簡介: 在二分搜尋法中，從數列的中間開始搜尋，如果這個數小於我們所搜尋的數，由於數列已排序，則該數左邊的數一定都小於要搜尋的對象，
* 所以無需浪費時間在左邊的數；如果搜尋的數大於所搜尋的對象，則右邊的數無需再搜尋，直接搜尋左邊的數。
* @param nums 待查找數組
* @num 待查找數
*/
public static int search(int[] nums, int num) {
int low = 0;
int high = nums.length - 1;

while (low <= high) {
int mid = (low + high) / 2;

//與中間值比較確定在左邊還是右邊區間,以調整區域
if (num > nums[mid]) {
low = mid + 1;
} else if (num < nums[mid]) {
high = mid - 1;
} else {
return mid;
}
}

return -1;
}

//二分查找的實現
public static void main(String[] args) {

int[] nums = { 2, 5, 11, 3, 22, 6, 91, 13, 35, 4 };
//對數組進行排序
QuickSort.sort(nums, 0, nums.length-1);

int find = BinarySearch.search(nums,5);

if (find != -1) {
System.out.println("找到數值於索引" + find);
} else {
System.out.println("找不到數值");
}
}
}

㈣ JAVA 二分查找

,在將100/。;2/2與20比較.collections，取一段已經排好序的數據段，不過由於針對必須是已經排好序的數據段進行操作.util。直到找出20，集合）進行操作的方法大多都封裝與java，有1-100數據，20<，推薦冒泡法
java中對數據段（數組二分查找原理，java開源，此方法操作速度較快;類下邊，也可以與我進行交流，qq，首先將100/2與20比較，演算法相當之精闢，依此類推
如;100/，需要查找20，樓主有興趣可以去看看他的源碼，用需要查找的數據與該數據段的1/。，使用較少;2處的數據進行比較;2，先將該數據段從中間切割開

㈤ JAVA里二分查找法 相關疑問

沒必要用遞歸，用循環就可以了。參考Arrays.binarySearch 的源碼吧

publicclassbinarySearch{
	staticintbinarySearch(int[]d,intl,inth,intv){
		intlow=l;
		inthigh=h-1;

		while(low<=high){
			intmid=(low+high)>>>1;
			intmidVal=d[mid];

			if(midVal<v)
				low=mid+1;
			elseif(midVal>v)
				high=mid-1;
			else
				returnmid;//keyfound
		}
		return-(low+1);//keynotfound.
	}

	publicstaticvoidmain(String[]args){
		java.util.Scannersc=newjava.util.Scanner(System.in);
		System.out.print("請輸入鍵值");
		intt=sc.nextInt();
		int[]data={12,13,24,35,44,67,78,98};

		inti=binarySearch(data,0,data.length,t);
		if(i>0)
			System.out.println("查找到值："+t+"("+i+")");
		else
			System.out.println("沒有查找到值："+t);
		sc.close();
		System.exit(0);

	}
}

㈥ 什麼叫java中的二分查找法

1、演算法概念。

二分查找演算法也稱為折半搜索、二分搜索，是一種在有序數組中查找某一特定元素的搜索演算法。請注意這種演算法是建立在有序數組基礎上的。

2、演算法思想。

①搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；

②如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。

③如果在某一步驟數組為空，則代表找不到。

這種搜索演算法每一次比較都使搜索范圍縮小一半。

3、實現思路。

①找出位於數組中間的值，並存放在一個變數中（為了下面的說明，變數暫時命名為temp）；

②需要找到的key和temp進行比較；

③如果key值大於temp，則把數組中間位置作為下一次計算的起點；重復① ②。

④如果key值小於temp，則把數組中間位置作為下一次計算的終點；重復① ② ③。

⑤如果key值等於temp，則返回數組下標，完成查找。

4、實現代碼。

/**
*description:二分查找。
*@paramarray需要查找的有序數組
*@paramfrom起始下標
*@paramto終止下標
*@paramkey需要查找的關鍵字
*@return
*/
publicstatic<EextendsComparable<E>>intbinarySearch(E[]array,intfrom,intto,Ekey)throwsException{
if(from<0||to<0){
("paramsfrom&lengthmustlargerthan0.");
}
if(from<=to){
intmiddle=(from>>>1)+(to>>>1);//右移即除2
Etemp=array[middle];
if(temp.compareTo(key)>0){
to=middle-1;
}elseif(temp.compareTo(key)<0){
from=middle+1;
}else{
returnmiddle;
}
}
returnbinarySearch(array,from,to,key);
}

㈦ 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(); //顯示。
}
}

㈧ 以下是二分查找的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;
}}
運行結果演示：

總結：

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