基礎排序（冒泡、選擇、插入）

前言

基本每個人入門數據結構和算法都是先經歷過排序，今天就來講解一下最基礎的三個入門排序算法。分別是冒泡排序、選擇排序和插入排序。

冒泡排序

思路：兩兩交換，小的往左邊，大的往右邊。

就是每趟過程把最大的數往右邊靠，然後從剩下的數繼續剛纔的過程。

代碼（冒泡排序）

package sort;

import java.util.Arrays;

/**
 * @author god-jiang
 * @date 2020/2/27  14:02
 */
public class BubbleSort {
    //冒泡排序，兩兩比較，小的往左邊，大的往右邊
    //時間複雜度O(n^2)  穩定排序  空間複雜度O(1)
    private static void sort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            //避免已經排好序了還要繼續循環下次
            boolean isSorded = true;
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    isSorded = false;
                }
            }
            if (isSorded) {
                break;
            }
        }
    }

    //交換兩數
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] array = new int[]{5, 2, 8, 1, 3, 4, 9, 7, 6};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

結果（冒泡排序）

---

選擇排序

思路：每一次從待排序的數據元素種選出最小的元素，存放在數組的起始位置，知道全部排序完成

每次都選出最小的，然後跟待排序的第一個數交換位置，直到全部排序完成。

代碼（選擇排序）

package sort;

import java.util.Arrays;

/**
 * @author god-jiang
 * @date 2020/2/27  14:18
 */
public class SelectionSort {
    //選擇排序
    //思路：從數組第一個數開始跟後面的數比較，最小和第一個交換，循環進行
    //時間複雜度：O(n^2)  空間複雜度O(1)  不穩定排序
    public static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                minIndex = array[minIndex] > array[j] ? j : minIndex;
            }
            swap(array, i, minIndex);
        }
    }

    //交換兩數
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] array = new int[]{2, 5, 6, 1, 4, 9, 7, 8, 3};
        selectionSort(array);
        System.out.println(Arrays.toString(array));
    }
}

結果（選擇排序）

---

插入排序

**思路：跟打撲克牌一樣。維持一個有序區，然後後面進來的數跟有序區比較，然後插入
**

代碼（插入排序）

package sort;

import java.util.Arrays;

/**
 * @author god-jiang
 * @date 2020/2/27  14:32
 */
public class ChaRuSort {
    //插入排序，跟打撲克牌一樣
    //時間複雜度O(n^2) 空間複雜度O(1)  穩定排序
    public static void sort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            for (int j = i - 1; j >= 0 && array[j] > array[j + 1]; j--) {
                swap(array, j, j + 1);
            }
        }
    }

    //交換兩數
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] array = new int[]{2, 5, 6, 1, 4, 9, 7, 8, 3};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

結果（插入排序）

總結

• 這三個基礎入門排序的時間複雜度都爲O(N^2)，空間複雜度都爲O(1)。
• 冒泡排序和插入排序都是穩定性排序，選擇排序不是穩定性排序。
• 本質上，冒泡排序的進階是快速排序。
• 本質上，插入排序的進階是希爾排序。