java的二分查找演算法

❶ 什麼叫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);
}

❷ 常見查找和排序演算法

查找成功最多要n 次，平均（n+1）/2次， 時間復雜度為O(n) 。
優點：既適用順序表也適用單鏈表，同時對表中元素順序無要求，給插入帶來方便，只需插入表尾即可。
缺點：速度較慢。

改進：在表尾設置一個崗哨，這樣不用去循環判斷數組下標是否越界，因為最後必然成立。

適用條件：

二分查找的判定樹不僅是二叉排序樹，而且是一棵理想平衡樹。 時間復雜度為O(lbn) 。

循環實現

遞歸實現

待排序的元素需要實現 Java 的 Comparable 介面，該介面有 compareTo() 方法，可以用它來判斷兩個元素的大小關系。

從數組中選擇最小元素，將它與數組的第一個元素交換位置。再從數組剩下的元素中選擇出最小的元素，將它與數組的第二個元素交換位置。不斷進行這樣的操作，直到將整個數組排序。

選擇排序需要 ~N2/2 次比較和 ~N 次交換，==它的運行時間與輸入無關==，這個特點使得它對一個已經排序的數組也需要這么多的比較和交換操作。

從左到右不斷 交換相鄰逆序的元素 ，在一輪的循環之後，可以讓未排序的最大元素上浮到右側。

在一輪循環中，如果沒有發生交換，那麼說明數組已經是有序的，此時可以直接退出。

每次都 將當前元素插入到左側已經排序的數組中 ，使得插入之後左側數組依然有序。

對於數組 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交換相鄰元素，令逆序數量減少 1，因此插入排序需要交換的次數為逆序數量。

==插入排序的時間復雜度取決於數組的初始順序，如果數組已經部分有序了，那麼逆序較少，需要的交換次數也就較少，時間復雜度較低==。

對於大規模的數組，插入排序很慢，因為它只能交換相鄰的元素，每次只能將逆序數量減少 1。希爾排序的出現就是為了解決插入排序的這種局限性，它通過交換不相鄰的元素，每次可以將逆序數量減少大於 1。

希爾排序使用插入排序對間隔 h 的序列進行排序。通過不斷減小 h，最後令 h=1，就可以使得整個數組是有序的。

希爾排序的運行時間達不到平方級別，使用遞增序列 1, 4, 13, 40, ... 的希爾排序所需要的比較次數不會超過 N 的若干倍乘於遞增序列的長度。後面介紹的高級排序演算法只會比希爾排序快兩倍左右。

歸並排序的思想是將數組分成兩部分，分別進行排序，然後歸並起來。

歸並方法將數組中兩個已經排序的部分歸並成一個。

將一個大數組分成兩個小數組去求解。

因為每次都將問題對半分成兩個子問題，這種對半分的演算法復雜度一般為 O(NlogN)。

先歸並那些微型數組，然後成對歸並得到的微型數組。

取 a[l] 作為切分元素，然後從數組的左端向右掃描直到找到第一個大於等於它的元素，再從數組的右端向左掃描找到第一個小於它的元素，交換這兩個元素。不斷進行這個過程，就可以保證左指針 i 的左側元素都不大於切分元素，右指針 j 的右側元素都不小於切分元素。當兩個指針相遇時，將切分元素 a[l] 和 a[j] 交換位置。

快速排序是原地排序，不需要輔助數組，但是遞歸調用需要輔助棧。

快速排序最好的情況下是每次都正好將數組對半分，這樣遞歸調用次數才是最少的。這種情況下比較次數為 CN=2CN/2+N，復雜度為 O(NlogN)。

最壞的情況下，第一次從最小的元素切分，第二次從第二小的元素切分，如此這般。因此最壞的情況下需要比較 N2/2。為了防止數組最開始就是有序的，在進行快速排序時需要隨機打亂數組。

因為快速排序在小數組中也會遞歸調用自己，對於小數組，插入排序比快速排序的性能更好，因此在小數組中可以切換到插入排序。

最好的情況下是每次都能取數組的中位數作為切分元素，但是計算中位數的代價很高。一種折中方法是取 3 個元素，並將大小居中的元素作為切分元素。

對於有大量重復元素的數組，可以將數組切分為三部分，分別對應小於、等於和大於切分元素。

三向切分快速排序對於有大量重復元素的隨機數組可以在線性時間內完成排序。

快速排序的 partition() 方法，會返回一個整數 j 使得 a[l..j-1] 小於等於 a[j]，且 a[j+1..h] 大於等於 a[j]，此時 a[j] 就是數組的第 j 大元素。

可以利用這個特性找出數組的第 k 大的元素。

該演算法是線性級別的，假設每次能將數組二分，那麼比較的總次數為 (N+N/2+N/4+..)，直到找到第 k 個元素，這個和顯然小於 2N。

堆中某個節點的值總是大於等於其子節點的值，並且堆是一顆完全二叉樹。

堆可以用數組來表示，這是因為堆是完全二叉樹，而完全二叉樹很容易就存儲在數組中。位置 k 的節點的父節點位置為 k/2，而它的兩個子節點的位置分別為 2k 和 2k+1。這里不使用數組索引為 0 的位置，是為了更清晰地描述節點的位置關系。

在堆中，當一個節點比父節點大，那麼需要交換這個兩個節點。交換後還可能比它新的父節點大，因此需要不斷地進行比較和交換操作，把這種操作稱為上浮。

類似地，當一個節點比子節點來得小，也需要不斷地向下進行比較和交換操作，把這種操作稱為下沉。一個節點如果有兩個子節點，應當與兩個子節點中最大那個節點進行交換。

將新元素放到數組末尾，然後上浮到合適的位置。

從數組頂端刪除最大的元素，並將數組的最後一個元素放到頂端，並讓這個元素下沉到合適的位置。

把最大元素和當前堆中數組的最後一個元素交換位置，並且不刪除它，那麼就可以得到一個從尾到頭的遞減序列，從正向來看就是一個遞增序列，這就是堆排序。

一個堆的高度為logN，因此在堆中插入元素和刪除最大元素的復雜度都為 logN。

對於堆排序，由於要對 N 個節點進行下沉操作，因此復雜度為 NlogN。

堆排序是一種原地排序，沒有利用額外的空間。

現代操作系統很少使用堆排序，因為它無法利用局部性原理進行緩存，也就是數組元素很少和相鄰的元素進行比較和交換。

計數排序的核心在於將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。作為一種線性時間復雜度的排序，==計數排序要求輸入的數據必須是有確定范圍的整數==。

當輸入的元素是 n 個 0 到 k 之間的整數時，它的==運行時間是 O(n + k)==。計數排序不是比較排序，排序的速度快於任何比較排序演算法。由於用來計數的數組C的長度取決於待排序數組中數據的范圍（等於待排序數組的最大值與最小值的差加上1），這使得計數排序對於數據范圍很大的數組，需要大量時間和內存。比較適合用來排序==小范圍非負整數數組的數組==。

桶排序是計數排序的升級版。它利用了函數的映射關系，高效與否的關鍵就在於這個映射函數的確定。為了使桶排序更加高效，我們需要做到這兩點：

同時，對於桶中元素的排序，選擇何種比較排序演算法對於性能的影響至關重要。

當輸入數據均勻分配到每一個桶時最快，當都分配到同一個桶時最慢。

實間復雜度N*K

快速排序是最快的通用排序演算法，它的內循環的指令很少，而且它還能利用緩存，因為它總是順序地訪問數據。它的運行時間近似為 ~cNlogN，這里的 c 比其它線性對數級別的排序演算法都要小。

使用三向切分快速排序，實際應用中可能出現的某些分布的輸入能夠達到線性級別，而其它排序演算法仍然需要線性對數時間。

❸ 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什麼是二分查找

什麼是二分查找？

二分查找也稱折半查找（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問題

什麼是二分查找？

二分查找也稱折半查找（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鐨刡inarySearch錛堬級鏂規硶

姒傝堪

binarysearch涓哄湪鎸囧畾鏁扮粍涓鏌ユ壘鎸囧畾鍊煎緱緔㈠紩鍊礆紝璇ュ煎湪鑼冨洿鍐呮壘寰楀埌鍒欒繑鍥炶ュ肩殑緔㈠紩鍊礆紝鎵句笉鍒板垯榪斿洖璇ュ肩殑鎻掑叆浣嶇疆錛屽傛灉璇ュ煎ぇ浜庢寚瀹氳寖鍥存渶澶у煎垯榪斿洖-錛坢axlength+1錛夛紝鑰岋細

int w=Arrays.binarySearch(a,1,5,8); 鏌ユ壘鐨勮寖鍥翠負緔㈠紩鍊1-5,錛2,3,4,5,6

8騫朵笉鍦ㄦよ寖鍥翠腑錛屼笖8澶т簬鏈澶х儲寮曞肩殑6錛屾墍浠ヨ繑鍥-錛5+1錛夛細-6

瑙ｆ瀽

鏌ョ湅java婧愮爜錛屽彲浠ョ湅鍒幫紝binarySearch錛堬級鏂規硶鏄閲嶈澆鏂規硶錛屾彁渚涗簡涓ょ嶅艦鍙傛柟寮忥細

灝忚創澹錛歜inarySearch錛堬級鏂瑰紡鍐呴儴瀹炵幇鐢ㄧ殑鏄浜屽垎娉曟煡鎵撅紝鎵浠ュ湪鏌ユ壘鍓嶉渶瑕佸皢鏁扮粍榪涜屾帓搴忥紝涓旀暟緇勪腑涓嶈兘鍑虹幇鐩稿悓鍏冪礌錛屽惁鍒欐煡鎵懼嚭鏉ョ殑緔㈠紩浼氫笉娓呮氭槸鍝涓涓鐨勶細

1錛夐粯璁よ寖鍥達紙鏁扮粍闀垮害錛夋煡鎵炬寚瀹氬肩儲寮曪細

鏍煎紡錛

binarySearch(object[ ], object key);

濡傛灉key鍦ㄦ暟緇勪腑錛屽垯榪斿洖鎼滅儲鍊肩殑緔㈠紩錛涘惁鍒欒繑鍥-1錛坘ey灝忎簬鏁扮粍涓鐨勪換鎰忎竴涓鍏冪礌錛夋垨鑰呪-鈥(鎻掑叆鐐)銆傛彃鍏ョ偣鏄緔㈠紩閿灝嗚佹彃鍏ユ暟緇勭殑閭ｄ竴鐐癸紝鍗崇涓涓澶т簬璇ラ敭鐨勫厓緔犵儲寮曘

key鐨勫煎湪鏁扮粍鑼冨洿鍐呭垯緔㈠紩浠0寮濮嬭℃暟錛

key鍊間笉瀛樺湪鏁扮粍鑼冨洿鍐咃紙澶т簬鏁扮粍鏈灝忓厓緔狅級鍒欎粠1寮濮嬭℃暟錛

瀹炰緥錛

importjava.util.Arrays;publicclasstest {publicstaticvoidmain(String[] args){int[]b=newint[]{4,25,10,95,06,21};System.out.println("鍘熸暟緇勪負錛");for(intdim1:b){System.out.print(""+dim1+" ");}Arrays.sort(b);System.out.println("鎺掑簭鍚庝負錛");for(intx:b){System.out.print(x+" ");}System.out.println();intindex=Arrays.binarySearch(b,2);System.out.println("鍏抽敭瀛2鐨勮繑鍥炲間負錛"+index);index=Arrays.binarySearch(b,20);System.out.println("鍏抽敭瀛20鐨勮繑鍥炲間負錛"+index);index=Arrays.binarySearch(b,30);System.out.println("鍏抽敭瀛30鐨勮繑鍥炲間負錛"+index);index=Arrays.binarySearch(b,100);System.out.println("鍏抽敭瀛100鐨勮繑鍥炲間負錛"+index);index=Arrays.binarySearch(b,10);System.out.println("鍏抽敭瀛10鐨勮繑鍥炲間負錛"+index);}}

//out:

鏁扮粍瀵逛簬姣忎竴闂ㄧ紪紼嬭璦鏉ヨ撮兘鏄閲嶈佺殑鏁版嵁緇撴瀯涔嬩竴錛屽綋鐒朵笉鍚岃璦瀵規暟緇勭殑瀹炵幇鍙婂勭悊涔熶笉灝界浉鍚屻

Java 璇璦涓鎻愪緵鐨勬暟緇勬槸鐢ㄦ潵瀛樺偍鍥哄畾澶у皬鐨勫悓綾誨瀷鍏冪礌銆

浣犲彲浠ュ０鏄庝竴涓鏁扮粍鍙橀噺錛屽 numbers[100] 鏉ヤ唬鏇跨洿鎺ュ０鏄 100 涓鐙絝嬪彉閲 number0錛宯umber1錛....錛宯umber99銆

鏈鏁欑▼灝嗕負澶у朵粙緇 Java 鏁扮粍鐨勫０鏄庛佸壋寤哄拰鍒濆嬪寲錛屽苟緇欏嚭鍏跺瑰簲鐨勪唬鐮併

Arrays 綾

java.util.Arrays 綾昏兘鏂逛究鍦版搷浣滄暟緇勶紝瀹冩彁渚涚殑鎵鏈夋柟娉曢兘鏄闈欐佺殑銆

鍏鋒湁浠ヤ笅鍔熻兘錛

• 緇欐暟緇勮祴鍊礆細閫氳繃 fill 鏂規硶銆

• 瀵規暟緇勬帓搴忥細閫氳繃 sort 鏂規硶,鎸夊崌搴忋

• 姣旇緝鏁扮粍錛氶氳繃 equals 鏂規硶姣旇緝鏁扮粍涓鍏冪礌鍊兼槸鍚︾浉絳夈

• 鏌ユ壘鏁扮粍鍏冪礌錛氶氳繃 binarySearch 鏂規硶鑳藉規帓搴忓ソ鐨勬暟緇勮繘琛屼簩鍒嗘煡鎵炬硶鎿嶄綔銆

1 public static int binarySearch(Object[] a, Object key)

鐢ㄤ簩鍒嗘煡鎵劇畻娉曞湪緇欏畾鏁扮粍涓鎼滅儲緇欏畾鍊肩殑瀵硅薄(Byte,Int,double絳)銆傛暟緇勫湪璋冪敤鍓嶅繀欏繪帓搴忓ソ鐨勩傚傛灉鏌ユ壘鍊煎寘鍚鍦ㄦ暟緇勪腑錛屽垯榪斿洖鎼滅儲閿鐨勭儲寮曪紱鍚﹀垯榪斿洖 (-(鎻掑叆鐐) - 1)銆

2 public static boolean equals(long[] a, long[] a2)

濡傛灉涓や釜鎸囧畾鐨 long 鍨嬫暟緇勫郊姝ょ浉絳夛紝鍒欒繑鍥 true銆傚傛灉涓や釜鏁扮粍鍖呭惈鐩稿悓鏁伴噺鐨勫厓緔狅紝騫朵笖涓や釜鏁扮粍涓鐨勬墍鏈夌浉搴斿厓緔犲歸兘鏄鐩哥瓑鐨勶紝鍒欒や負榪欎袱涓鏁扮粍鏄鐩哥瓑鐨勩傛崲鍙ヨ瘽璇達紝濡傛灉涓や釜鏁扮粍浠ョ浉鍚岄『搴忓寘鍚鐩稿悓鐨勫厓緔狅紝鍒欎袱涓鏁扮粍鏄鐩哥瓑鐨勩傚悓鏍風殑鏂規硶閫傜敤浜庢墍鏈夌殑鍏朵粬鍩烘湰鏁版嵁綾誨瀷錛圔yte錛宻hort錛孖nt絳夛級銆

3 public static void fill(int[] a, int val)

灝嗘寚瀹氱殑 int 鍊煎垎閰嶇粰鎸囧畾 int 鍨嬫暟緇勬寚瀹氳寖鍥翠腑鐨勬瘡涓鍏冪礌銆傚悓鏍風殑鏂規硶閫傜敤浜庢墍鏈夌殑鍏朵粬鍩烘湰鏁版嵁綾誨瀷錛圔yte錛宻hort錛孖nt絳夛級銆

4 public static void sort(Object[] a)

瀵規寚瀹氬硅薄鏁扮粍鏍規嵁鍏跺厓緔犵殑鑷鐒墮『搴忚繘琛屽崌搴忔帓鍒椼傚悓鏍風殑鏂規硶閫傜敤浜庢墍鏈夌殑鍏朵粬鍩烘湰鏁版嵁綾誨瀷錛圔yte錛宻hort錛孖nt絳夛級銆

❼ 用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;
}

}

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