Java中的選擇排序、冒泡排序及折半查找

Java中的排序方法有很多，下面對選擇排序和冒泡排序作個簡單瞭解，旨在對排序算法的直觀理解，不考慮排序性能。

選擇排序：

import java.util.Arrays;

public class SelectSort {
    //定義一個對數組的選擇排序，每一次拿一個數和後面的所有數作比較，每次把最值（最大或最小）排在靠前的位置
    public static void selectSort(int[] arr) {    
        for (int x=0; x<arr.length-1; x++) {
            for (int y=x+1; y<arr.length; y++) {
                //對每兩個數比較的結果由小到大進行排序，如果換成arr[x] < arr[y]，則由大到小
                if (arr[x] > arr[y]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
    
    //方法測試
    public static void main(String[] args) {
        int[] a = {7, 3, 5, 9, 6, 1, 8, 2, 4};
        System.out.println("排序前：" + Arrays.toString(a));
        selectSort(a);
        System.out.println("排序後：" + Arrays.toString(a));
    }
}

冒泡排序：

import java.util.Arrays;

public class BubbleSort {
    //定義一個對數組的冒泡排序，每兩個相鄰的數依次作比較，每次把最值（最大或最小）排在靠后的位置
    public static void bubbleSort(int[] arr) {
        for (int x=0; x<arr.length-1; x++) {
            //y<arr.length-x-1;其中減x是讓每次比較的元素減少，-1是為防止角標越界
            for (int y=0; y<arr.length-x-1; y++) {
                //對每兩個數比較的結果由小到大進行排序，如果換成arr[y] < arr[y+1]，則由大到小
                if (arr[y] > arr[y+1]) {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }

    //方法測試
    public static void main(String[] args) {
        int[] a = {7, 3, 5, 9, 6, 1, 8, 2, 4};
        System.out.println("排序前：" + Arrays.toString(a));
        bubbleSort(a);
        System.out.println("排序後：" + Arrays.toString(a));
    }
}

運行結果：

在實際開發中並不使用以上排序方法進行排序，而是直接用java.util.Arrays;里提供的方法對數組進行排序和其他操作。

Arrays里的都是靜態方法，可直接用Arrays類名調用，如排序：Arrays.sort(arr)，還有Arrays.binarySearch(int[] a, int key)、Arrays.toString(arr)等。

 

--------------------------------------------------------------------------------------------------

折半查找：

import java.util.Arrays;

public class BinarySearch {
    //折半查找，也叫二分法查找，即查找一個數在一個有序數組中的位置，若該數組中不存在這個數，則返回插入位置的值取反再-1。
    public static int getIndex(int[] arr, int key) {
        //min為角標區間最小值，max為角標區間最大值，mid為角標區間中間值
        int min = 0, max = arr.length - 1, mid;
        while(min <= max) {
            mid = (min + max) >> 1;
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            } else {
                return mid; //返回key在數組中的位置
            }
        }
        return -min - 1; //找不到則返回插入位置的值取反再-1
    }
    
    //方法測試
    public static void main(String[] args) {
        int[] a = {7, 3, 5, 9, 6, 1, 4, 8, 2};
        System.out.println("排序前的數組：" + Arrays.toString(a));
        Arrays.sort(a); //需先對數組進行排序
        System.out.println("排序后的數組：" + Arrays.toString(a));
        int b = BinarySearch.getIndex(a, 6);
        System.out.println("查找的數在數組中的位置：" + b);
    }
}

運行結果：

 

拆半查找可以有效提高查找效率，折半查找的前提是該數組必須是有序的。

在實際開發中同樣使用Arrays工具類中定義好的方法即可。