1. 說明

這裡的演算法主要是自己這段時間為了面試複習而記錄的，只符合自己的閱讀習慣，且只是用程式碼實現了一下，並沒有詳細的原理介紹。

2. 常見的演算法

面試時要會寫如下五種常見的演算法
a.氣泡排序
b.快速排序(冒泡改進版)
c.選擇排序
d.直接插入排序
e.希爾排序(直接插入排序改進版)

3. 程式碼實現

/**
 * 1.氣泡排序  對比的次數是N-1次,兩兩比較，將最大的是挪到最後    經過N次排序，最後的N個數是有序的
 * 要點：1.識別符號，如果第一次沒有變化，則是有序的   2.排序的次數length-1    3.第i次比較的範圍 0到length-i（i從1開始）
 *
 * @param array 待排序的陣列
 * @return 排好序的陣列
 */
public int[] bubbleSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        for (int j = 0; j < array.length - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
        System.out.println("冒泡第" + i + "次排序的結果為");
        display(array);
    }
    return array;
}


/**
 * 2.選擇排序   需要N-1輪比較   每一次都是講最小的數選擇出來，插入到當前需要排序的位置
 * 要點：1.比較的輪數  len -1 2.每一輪待插入元素的位置  3.比較，如果該位置不是最小的數值，將最小的數和待排序的數對調
 *
 * @param array 待排序的陣列
 * @return 已經排好序的陣列
 */
public int[] choiceSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[min]) {
                min = j;
            }
            if (i != min) {
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
        }
        System.out.println("選擇第" + i + "次排序的結果為");
        display(array);
    }
    return array;
}


/**
 * 3.直接插入排序
 * 要點：首先要選擇好待排序的那個數，在while迴圈中參與比較的數是temp,待比較的數
 *
 * @param array 倒排序的陣列
 * @return 排好序的陣列
 */
public int[] straightInsert(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        int j = i + 1;
        int temp = array[j];
        while (j > 0 && temp < array[j - 1]) {
            array[j] = array[j - 1];
            j--;
        }
        array[j] = temp;
        System.out.println("直接插入第" + i + "次排序的結果為");
        display(array);
    }
    return array;
}

/**
 * 4.快速排序-氣泡排序的改進版，原理是選擇一個基準位，每一次元陣列分成兩部分，一部分比基準數大，另一部分比基準數小
 * 注意：這個是簡單版的快速排序，直接選擇第一個數為基準數
 * 以下例子利用了分治演算法的快速排序，選擇一個目標數字，將待排序的陣列分成兩個，
 * 一部分都比這個數字大，一部分都比這個數字小
 * <p>
 * <p>
 * 減少氣泡排序過程中比較的次數
 */
public void quickSort(int[] arr, int low, int high) {
    int i, j, base, temp;
    if (low > high) {
        return;
    }
    i = low;
    j = high;
    //base是基準位，選擇第一個數字為基準位
    base = arr[low];
    while (i < j) {
        //先看右邊，依次往左遞減
        while (base <= arr[j] && i < j) {
            j--;
        }
        //再看左邊，依次往右遞增
        while (base >= arr[i] && i < j) {
            i++;
        }
        //如果條件滿足則交換
        if (i < j) {
            temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
    }
    //最後將基準與i和j相等位置的數字調換，因為在上述交換的過程中，base上的資料肯定是不變的，也就是arr[low]不變
    arr[low] = arr[i];
    arr[i] = base;
    //遞迴呼叫左半邊
    quickSort(arr, low, j - 1);
    //遞迴呼叫右半邊，因為數字J在的位置已經是有序的，所以不再參與排序
    quickSort(arr, j + 1, high);

}


/**
 * 2h的shell排序，是直接插入排序的改進，希爾排序通過加大插入排序中元素的間隔，並在這些有間隔的元素中進行插入排序，從而使資料項能夠大跨度的移動。
 *
 * @param array
 */
public void shellSortFor2h(int[] array) {
    int step;
    int len = array.length;
    for (step = len / 2; step > 0; step /= 2) {
        for (int i = step; i < len; i++) {
            int j = i;
            int temp = array[j];
            if (array[j] < array[j - step]) {
                while (j - step >= 0 && temp < array[j - step]) {
                    array[j] = array[j - step];
                    j -= step;
                }
                array[j] = temp;
            }
        }
    }
}


//遍歷顯示陣列
public static void display(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

public static void main(String[] args) {
    AlgorithmInteview algorithmInteview = new AlgorithmInteview();
    int[] array = {9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 0};
    //未排序陣列順序為
    System.out.println("未排序陣列順序為：");
    display(array);
    System.out.println("-----------------------");
    algorithmInteview.straightInsert(array);
    System.out.println("-----------------------");
    System.out.println("經過排序後的陣列順序為：");
    display(array);
}