java的数组查找算法_java数组、排序算法、查找算法详解
1、為什么定義數(shù)組要采用type[] arrayName;這種方式？
因為這種方式具有很好的可讀性，使用這種方式很容易就可以理解這是定義一個變量，其中變量名是arrayName，變量的類型是type[]。
2、定義數(shù)組是為什么不可以指定數(shù)組的長度？
我們知道數(shù)組是一種引用類型的變量，因此使用它來定義一個變量時，僅僅表示定義了一個引用變量(也就是定義了一個指針)，這個引用變量還未指向任何有效內(nèi)存，因此定義數(shù)組時不能指定數(shù)組的長度。
因為定義數(shù)組只是定義了一個引用變量，并未指向任何有效的內(nèi)存空間，所以還沒有內(nèi)存空間來存儲數(shù)組元素，因此這個數(shù)組也不能使用，只有對數(shù)組進(jìn)行初始化之后才可以使用。
Arrays：針對數(shù)組進(jìn)行操作的工具類。屬于util包。沒有構(gòu)造方法。但是這個類的方法都是靜態(tài)方法，可以通過類直接調(diào)用
public static String toString(T[] a)：把數(shù)組轉(zhuǎn)換成字符串
public static void sort(T[] a)：對數(shù)組進(jìn)行排序(底層是快速排序)
public static int binarySearch(T[] a,Tkey)：二分查找
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
System.out.println(Arrays.toString(arr)); //[24, 69, 80, 57, 13]
System.out.println(Arrays.binarySearch(arr, 57)); //-2(為什么呢？看后面的源碼找答案)
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); //[13, 24, 57, 69, 80]
System.out.println(Arrays.binarySearch(arr, 57)); //2
}
}
為了更加深刻的了解這些方法的原理，下面貼出源碼以供理解：
這個是toString的源碼：只要是對象，我們在使用之前都要判斷是不是null，以防出現(xiàn)空指針異常
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
binarySearch的源碼：
public static int binarySearch(int[] a, int key) {
return binarySearch0(a, 0, a.length, key);
}
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
冒泡排序
1、相鄰元素兩兩比較，大的往后面放。
2、第一次排序完畢后，最大值就出現(xiàn)在了最大索引處。
3、第二次排序，最后一個索引的位置就不需要比較了
4、第三次排序，倒數(shù)第二個索引位置就不需要比較了
用i來表示比較的次數(shù)。每一次都會從索引為0的位置開始向后比較。
第一輪：i = 1，j 的范圍是第一個到最后一個，所以j的索引范圍是[0,arr.length-1](arr.length-1是數(shù)組最后一個位置的索引，看成一個整體)
第一輪之后，會確定一個最大值。因此第二輪比較的時候就不用去比較這個最大值了。
第二輪：i = 2，因為第一輪已經(jīng)確定了一個最大值，有1個元素不會參與比較。因此第二輪 j 的索引范圍變成了[0,(arr.length-1)-1]
第二輪比較之后，會確定兩個應(yīng)該在數(shù)組末尾的兩個值。第三輪就不用去比較這兩個值了。
第三輪：i = 3，因為第二輪已經(jīng)確定了兩個大值了，有2個元素不會參與比較。因此第三輪 j 的索引范圍變成了[0,(arr.length-1)-2]
……..
依次類推：第 i 次 j 的索引范圍應(yīng)該是：[0,(arr.length-1)-(i-1)]
代碼如下：
public class BubbuleDemo {
public static void main(String[] args) {
int[] arr = { 24, 69, 80, 57, 13 };
bubbleSort(arr);
}
// 冒泡排序
public static void bubbleSort(int[] arr) {
for (int i = 1; i <= arr.length - 1; i++) { // 控制比較的次數(shù)。次數(shù) = 數(shù)組長度-1
for (int j = 0; j < (arr.length - 1) - (i - 1); j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
選擇排序
1、從索引為0的地方開始，依次和后面的比較，小的往前放
2、第一次比較從0索引開始往后比較。第一次比較完畢后，最小的元素就出現(xiàn)在了第一個位置上。
3、第二次比較的時候就不比較第一個元素了，就會從第二個元素開始比較。也就是第二次比較從1索引開始比較。
第二次比較完畢后，第二小的就出現(xiàn)在了第二個位置上。
4、第三次比較的時候就不比較前兩個元素了，就會從第三個元素開始比較.也就是第三次比較從2索引開始比較。
…….
第 n 比較的時候就不比較前(n-1)個元素了，會從第n個元素開始比較。也就是第n次比較從(n-1)索引開始比較。
public class SelectSort {
public static void main(String[] args) {
int[] arr = { 24, 69, 80, 57, 13 };
selectSort(arr);
}
public static void selectSort(int[] arr) {
for (int i = 0; i <= (arr.length - 2); i++) { //已經(jīng)確認(rèn)好的值的個數(shù),比如：確定了0個人，就從0索引開始依次跟后面的比較
for (int j = i + 1; j <= (arr.length - 1); j++) {
if (arr[i] > arr[j]) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " "); //13 24 57 69 80
}
}
}
二分查找(折半查找算法)：數(shù)組元素有序的情況下
1、每次都去找中間的那個元素，跟要查找的元素比較，
2、如果中間元素的值 > 要查找的值，就在左半部分找
3、如果中間元素的值 < 要查找的值，就在右半部分找
注意：只有有序數(shù)組才可以使用這個方法。不可以對無序數(shù)組采用二分查找，不可以先排序再二分查找，因為你的數(shù)組元素都變了，你查找的索引已經(jīng)不再是原始數(shù)組的索引了。
public class BinarySearch {
public static void main(String[] args) {
int[] arr = { 11, 23, 34, 46, 57, 68, 79, 80 };
System.out.println(binarySearch(arr, 57)); //4
}
//二分查找
public static int binarySearch(int[] arr, int value) {
int min = 0;
int max = arr.length - 1;
int mid = (max + min) / 2;
while (min <= max) {
if (arr[mid] > value) {
max = mid - 1;
} else if (arr[mid] < value) {
min = mid + 1;
}else{
return mid;
}
mid = (max + min) / 2;
}
return -1; //找不到的情況
}
}
總結(jié)
以上是生活随笔為你收集整理的java的数组查找算法_java数组、排序算法、查找算法详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java 中如何实现多进程_在Java中
- 下一篇： java 泛型int_Java 泛型