java二分法查找

A. 用java編寫程序實現「採用二分法查找一個數」。

public class Lookup {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 二分法查找
*/
int a[]={23,45,98,100,110,120,140};
int search=120;//記錄要查找的元素
int lower=0;//記錄第一個元素
int temp=a.length-1 ;
int index=-1;
while(lower<=temp){
index = (lower+temp)/2;//記錄中間元素，用兩邊之和除2.
int currentValue=a[index];
if(currentValue==search){//如果得到的數與要查找的數相等則break退出;
break;
}else if(currentValue<碰茄search){//如果得到的數要小於查找的數、就用下標加1;否則減一
lower=index+1;
}else{
temp = index-1;
}
}
if(lower<=temp){
System.out.println(search+"在數組中第笑畢察："+(index+1)+"位");
}else{
System.out.println("裡面沒有這個數段元素");

B. 怎麼計算java二分法查找的比較次數

您好，橋李我來為稿帆您解答：
演算法：當數據量很大適宜採用該方法。採用二分法查找時，數據需是有序不重復的。
基本思想：假設數據是按升序排序的，對於給定值
x，從序列的中間位置開始比較，如果當前位置值等於
x，則查找成敏敬遲功；若
x
小於當前位置值，則在數列的前半段中查找；若
x
大於當前位置值則在數列的後半段中繼續查找，直到找到為止。
希望我的回答對你有幫助。

C. 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;
		}
	}
}

D. java二分法查找重復數字的下標

package pers.ly.javase.algorithm;import java.util.Arrays;/**
* 二分法查找
* @author: Lu Yang
* @date: 2019-01-23 10:50:37
*
*/public class BinarySearch {

public static void main(String[] args) {
Integer[] arr = {10,50,30,40,10,80,90,70,60,40,100,10};
// 數組排序 -> 二分擾搜法必要條件
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(binarySearch(arr,50));
}

/**
*
* @author: Lu Yang
* @date: 2019-01-23 11:44:01
* @param arr 數組
* @param value 數組元素值
* @return
*
*/
public static Integer binarySearch(Integer[] arr, Integer value) {
// 定義數組開始位置
Integer start = 0;
// 定義數組結束位置(arr.length是計算數組從1開始的總長度,arr.length-1計算數緩清歷組從0開始的總長度)
Integer end = arr.length - 1;

/正彎/ 開始位置 <= 結束位置
while (start <= end) {
// 定義數組的中心位置(開始位置+結束位置)/2
Integer mid = (start + end) / 2;
// 判斷數組mid位置值(當前數據中間位置值)是否小於傳過來的值
if (arr[mid] < value)
// 如果小於傳過來的值,數組開始位置則定義中間位置下標+1
start = mid + 1;

// 判斷數組mid位置值(當前數據中間位置值)是否大於傳過來的值
if (arr[mid] > value)
// 如果大於傳過來的值,數組結束位置則定義中間位置下標-1
end = mid - 1;

if (arr[mid] == value)
return mid;

}
return -1;
}}

E. 用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;
}

}

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

F. 怎麼計算java二分法查找的比較次數

您好，我來為您解答：
演算法：當數據量很大適宜採用該方法。採用二分法查找時，數據需是有序不重復的。 基本思想：假設數據是按升序排序的，對於給定值 x，從序列的中間位置開始比較，如果當前位置值等於 x，則查找成功；若 x 小於當前位置值，則在數列的前半段中查找；若 x 大於當前位置值則在數列的後半段中繼續查找，直到找到為止。
希望我的回答對你有幫助。

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

H. java程序 二分法查找一個數

public class Lookup {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 二分法查找
*/
int a[]={23,45,98,100,110,120,140};
int search=120;//記錄要查找的元素
int lower=0;//記錄第一個元素
int temp=a.length-1 ;
int index=-1;
while(lower<=temp){
index = (lower+temp)/2;//記錄中間元素，用兩邊之和除2.
int currentValue=a[index];
if(currentValue==search){//如果得到的數與要查找的數相等則break退出;
break;
}else if(currentValue<search){//如果得到的數要小州塵於查找的數冊型禪、就用下標租燃加1;否則減一
lower=index+1;
}else{
temp = index-1;
}
}
if(lower<=temp){
System.out.println(search+"在數組中第："+(index+1)+"位");
}else{
System.out.println("裡面沒有這個元素");
}
}
}