二分查詢

二分查詢演算法也稱為折半搜尋、二分搜尋
在有序陣列中查詢某指定元素的搜尋演算法。企業面試常見考試的型別。
* 有序：二分查詢法只適用於有序的陣列，對於無序的陣列如果想要使用二分查詢法查詢某資料，必須先對目標陣列進行排序。

• 原理：二分查詢法，即對一個有序的陣列每次取陣列中間下標的資料與目標key值進行比較，快速縮小查詢範圍。

/**
 * 6,8,10,12,14,16,18,20--midVal = 12 > key
 * 6,8,10                --midVal = 8  < key
 * 10                    --midVal = 10 ==key 查詢成功
 */
 

public class Test01_BinarySearch {
    public static void main(String[] args) {
        int[] a = {6,8,10,12,14,16,18,20};// 測試陣列
        int key = 10;// 目標key值
        int index = binarySearch(a,key);// 使用我們寫的二分查詢法進行查詢
        System.out.println("binarySearch:"+key+" index:"+index);

        int arrays = Arrays.binarySearch(a, key);// 呼叫Java官方提供的二分查詢法查詢資料
 

        System.out.println("Arrays:"+key+" index:"+arrays);
    }

    private static int binarySearch(int[] a, int key) {
        int low = 0;// 記錄最小下標
        int high = a.length-1;// 記錄最大下標
        while(low <= high){// 當low > high時說明陣列中沒有查詢的key值
            int mid = (low+high) >>> 1;// 計算中間下標
 

            int midVal = a[mid];// 取得中間下標對應的值

            if(midVal > key){// 將中間值與目標key值進行比較
                high = mid-1;// 查詢範圍減半
            }else if(midVal < key){
                low = mid+1;
            }else{
                return mid;
            }
        }
        return -1;// 查詢資料不存在
    }
}

排序

排序是計算機程式設計中的一種重要操作，是指將一個任意的序列，排列成一個關鍵字有序的序列。

選擇排序

• 原理：每一趟從待排序的資料元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的資料元素排完。

public class Test02_SelectSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        Random random = new Random();
        for(int i=0;i<a.length;i++){        
            a[i] = random.nextInt(100);
        }// 利用隨機數產生一個隨機陣列
        System.out.println(Arrays.toString(a));
        selectSort(a);// 排序
        System.out.println(Arrays.toString(a));

    }

    // 選擇排序，降序
    static void selectSort(int[] a){
        for(int i=0;i<a.length;i++){// 外層迴圈每一趟完成一個位置上資料的排序
            // 內層迴圈將該位置上的元素與其他所有元素進行比較，確定該位置上的元素，如第一次找到最大值放在第一個
            for(int j=i+1;j<a.length;j++){
                if(a[j]>a[i]){// 如果有元素大於該位置上的元素，就交換兩個元素
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
    } 
}

氣泡排序

• 原理：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。升序

public class Test03_BubbleSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        Random random = new Random();
        for(int i=0;i<a.length;i++){
            a[i] = random.nextInt(101);
        }
        System.out.println(Arrays.toString(a));

        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }

    // 氣泡排序
    static void bubbleSort(int[] a){
        for(int i=1;i<a.length;i++){
            for(int j=0;j<a.length-i;j++){// 內層迴圈迴圈一次選出一個最大的數放在陣列最後
                if(a[j] > a[j+1]){
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                }
            }
        }
    }
}

插入排序

• 原理:將資料插入到已經排好序的有序資料中，得到一個新的、個數加一的有序資料。

public class Test04_InsertSort {

    public static void main(String[] args) {
        int[] a = new int[10];
        Random random = new Random();
        for (int i = 0; i < a.length; i++) {
            a[i] = random.nextInt(101);
        }
        System.out.println(Arrays.toString(a));
        insertSort(a);
        System.out.println(Arrays.toString(a));
    }

    static void insertSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int k = a[i];
            int j;
            for (j = i - 1; j >= 0 && k > a[j]; j--) {
                a[j + 1] = a[j];
            }
            a[j + 1] = k;
        }
    }
}

快速排序

快速排序的過程是首先選擇一個基準，如下標為0的數值。先從後往前找一個比基準大的數，然後將此數值與基準交換，再從前往後找一個比基準小的數值，然後在將此小數值與基準交換。如此反覆…

• 原理：快速排序使用分治法來設計演算法：取一個基準元素，拆分之後基準元素左邊的都比基準元素大，右邊的元素都比基準元素小，然後分別對兩個子陣列排序。降序

public class Test05_QuickSort {
    public static void main(String[] args) {
        int[] a = new int[10];
        Random random = new Random();
        for(int i=0;i<a.length;i++){
            a[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(a));

        quickSort(a,0,a.length-1);
        System.out.println(Arrays.toString(a));
    }

    private static void quickSort(int[] a, int low, int high) {
        if(low>=high){// 遞迴的中止條件
            return;
        }
        int l = low;
        int h = high;
        boolean isRight = false;
        while(l < h){
            if(a[l] < a[h]){
                int t = a[l];
                a[l] = a[h];
                a[h] = t;
                isRight = !isRight;
            }
            if(isRight){
                l++;
            }else{
                h--;
            }
        }
        quickSort(a,low,l-1);// 對子陣列進行排序
        quickSort(a,l+1,high);
    }
}