JAVA 基礎知識點複習（五）數組和排序

這系列博文主要是將自己之前學習的一些java基礎內容進行歸納與總結。

一維數組

數組可以存儲多個相同類型的數據並對其從0開始編號，通過編號（索引）完成對元素的操作。

數組一旦定義，所佔用的內存空間就固定了，所以數組不可變。

一維數組定義方式有三種，二三種寫法比較常見。

// （一）靜態初始化
int[] arr = new int[]{1,2,3};
// （二）靜態初始化
int[] arr1 = {1,2,3};
// （三）動態初始化
int[] arr2 = new int[3];

// 對於動態初始化，只是確定容量，無法判斷實際存儲了多少元素
System.out.println(arr2.length);

// 遍歷
for (Integer val : arr) {
    System.out.print(val);
}

// 使用工具類快捷打印
System.out.println(Arrays.toString(arr))；

二維數組

數組嵌套數組，二三種寫法比較常見

// （一）靜態初始化
int[][] arrs = new int[][]{{1}, {2, 3}, {4, 5, 6}};
// （二）靜態初始化
int[][] arrs1 = {{}, {}, {}};
// （三）動態初始化
int[][] arrs2 = new int[2][3];
// （四）動態初始化 也可只定義第一維度的容量
int[][] arrs3 = new int[3][];

System.out.println(arrs.length); // 第一維度的容量

// 遍歷
for (int[] arr : arrs) {
    for (Integer val : arr) {
        System.out.print(val);
    }
}

// 使用工具類快捷打印
System.out.println(Arrays.deepToString(arrs));

二維數組其實就是一個矩陣，對於動態初始化來說new int[][]第一個[]代表着這個二維數組中有多少個一維數組，第二個[]代表着一維數組的容量,並且第一個[]不能爲空

當然也可以定義個N維數組[狗頭]

int[][][][][] i = new int[2][2][2][2][2];
System.out.println(Arrays.deepToString(i));

一些比較奇怪的寫法

int x []; // 不推薦
int x1 [][]; // 不推薦
int [] x2 []; // 會被打
int[] x3, y[]; // x3是一維數組，y是二維數組

冒泡排序

兩兩相鄰元素進行排序，將最大（最小）的放置最後

時間複雜度O(N^2)

第一次內循環比較n - 1次，然後是n-2次，n-3次，……，最後一次內循環比較1次。

等差數列求和
$((n-1)+1)(n-1)/2=n(n-1)/2$
Big O表示法：只保留最高項，並且去除最高項常數

最終推導爲 O(N^2)

private static void bubbleSort(int[] arr){
        for (int i=0; i<arr.length-1; i++) {
            for (int j=0; j<arr.length-1-i; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

簡單選擇排序

將第i位數與其後的所有數做比較，當遇到小於（大於）的就將其角標存儲，每一輪結束如果角標有變動則進行交換，第i個數就是最小（最大）的

時間複雜度O(N^2)

第一次內循環比較n - 1次，然後是n-2次，n-3次，……，最後一次內循環比較1次。

求等差數列和
$((n-1)+1)(n-1)/2=n(n-1)/2$
最終推導爲 O(N^2)

private static void selectSort(int[] arr){
    for (int i = 0; i < arr.length - 1; i++) {
        int index = i;
        for (int j = i+1; j < arr.length; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        if (index != i) {
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
    }
}

快速排序

時間複雜度O(NLogN)
指針交換法

private static void quickSort(int[] arr, int left, int right){
        if(left >= right){
            return;
        }
        // 左哨兵i, 右哨兵j, 基準數pivot
        int i = left, j = right, pivot = arr[i];
    	// 這裏必須j先動，否則ij相遇時的元素必定大於基準數，因爲i是遇到大於基準數的才停止
        while(i < j){
            // j先動遇到小於等於基準數的就停止
            while (arr[j] >= pivot && i < j) {
                j--;
            }
            // i後動遇到大於等於基準數的就停止
            while (arr[i] <= pivot && i < j){
                i++;
            }
            // 交換兩個指針元素
            if(i < j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 第一輪循環好後就能確定重合點，將基數與重合點元素交換
        arr[left] = arr[i];
        arr[i] = pivot;
        // 遞歸調用左邊
        quickSort(arr, left, i - 1);
        // 遞歸調用右邊
        quickSort(arr, i + 1, right);
    }

二分查找

private static int binarySearch(int[] arr, int key){

        int min = 0, mid, max = arr.length-1;
        while(min <= max){
            mid = (min + max)/2;
            if(key > arr[mid]){
                min = mid + 1;
            }else if(key < arr[mid]){
                max = mid - 1;
            }else {
                return mid;
            }
        }
        return -1;
    }