Java程式設計中快速掌握搜尋演算法和排序演算法的方法

一、搜尋演算法

二分演算法

二分演算法（Binary Search）又稱折半查找，是一種高效率的查找演算法。它的基本想法是：將有序數組（或集合）一分為二，若當前中間元素等於目標元素，則查找成功；若當前中間元素大於目標元素，則查找左半部；若當前中間元素小於目標元素，則尋找右半部。重複以上步驟，直到查找到目標元素或尋找區間為空，尋找失敗。

下面是用Java實現的二分演算法：

public static int binarySearch(int[] arr, int target) {
    if (arr == null || arr.length == 0) {
        return -1;
    }
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}

上述方法使用了一組有序的整數數組和一個目標值作為參數，並傳回目標值在數組中的索引；如果目標值不存在於數組中，就回傳-1。

演算法的核心是while 循環，它在left 和right 滿足特定條件的情況下反覆執行：

• 如果mid 等於target，則傳回mid，演算法結束;

• 如果mid 大於target，則在左側繼續尋找，即將right 設定為mid - 1;

• 如果mid 小於target，則在右側繼續查找，即將left 設定為mid 1。

每次迴圈時，我們使用 mid = left (right - left) / 2 計算出中間元素的索引。要注意的是，我們必須使用 left right 的形式，而不能使用 (left right) / 2 的形式，否則可能會導致整數溢位問題。

二、排序演算法

在Java中，排序演算法是透過實作Comparable或Comparator介面來實現的。以下是幾種常用的排序演算法和它們的實作方法：

冒泡排序

冒泡排序是一種簡單的排序演算法。它的想法是不斷地比較相鄰的兩個元素，如果順序不對，就交換位置。這個過程就像水泡不斷往上升一樣，所以叫冒泡排序。

public static void bubbleSort(int[] arr) {
    int temp;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                //交换位置
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

選擇排序

選擇排序的想法是，從未排序的元素中選擇最小的元素放到已排序的結尾。每次找到最小元素後，與目前未排序的第一個元素交換位置。

public static void selectionSort(int[] arr) {
    int minIndex;
    for (int i = 0; i < arr.length - 1; i++) {
        minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        //交换位置
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

插入排序

插入排序的想法是，將未排序元素插入到已排序的適當位置。從未排序的元素中選擇一個元素，在已排序的元素中從後往前遍歷，如果比已排序的元素小，則向後移動一個位置，繼續比較；直到找到比未排序的元素小的位置，然後插入到這個位置。

public static void insertionSort(int[] arr) {
    int preIndex, current;
    for (int i = 1; i < arr.length; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
}

快速排序

快速排序是一種基於分治思想的排序演算法。它選擇一個基準點，將數組分成小於等於基準點和大於基準點的兩個子數組，然後遞歸地對兩個子數組排序。

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int i = left, j = right, pivot = arr[left];
        while (i < j) {
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        arr[i] = pivot;
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
}

以上是Java程式設計中快速掌握搜尋演算法和排序演算法的方法的詳細內容。更多資訊請關注PHP中文網其他相關文章！