一、排序演算法概述

排序演算法最常用操作：交換元素

public void sort(int[] arr, int i, int j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
    }

二、氣泡排序

2.1 實現原理

第一種：元素上浮，從右（大）往左（小）依次確認，相鄰元素間，如果右小於左，則交換，每次確認一位最小數。

第二種：元素下沉，從左（小）往右（大）依次確認，相鄰元素間，如果左大於右，則交換，每次確認一位最大數。

2.2 動圖解析

3.3 程式碼實現

public static void main(String[] args) {
        Object [] arr = {23,42,21,33,44,55,34,65,77,20,"A","b",90};
        for (Object o : bubbleSort(arr)) {
            System.out.print(o+" ");
        }
}

public static Object[] bubbleSort(Object[] arr){
        //排除空異常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //從末尾元素開始確定
        for (int i = arr.length - 1; i > 0; i--) {
            //判斷是否存在交換
            boolean flag = false;
            for (int j = 0; j < i; j++) {
                if (arr[j].hashCode() > arr[j + 1].hashCode()) {
                    sort(arr, j, j + 1);
                    flag = true;
                }
            }
            //如果不再存在交換，則排序完畢，直接退出
            if (!flag) {
                break;
            }
        }

        return arr;
}

結果：

三、選擇排序

3.1 實現原理

第一種：拿未確認的最左位元素，依次和右邊元素比較，如果右邊元素更小，則交換

第二種：拿未確認的最右位元素，依次和左邊元素比較，如果左邊元素更大，則交換

3.2 動圖解析

3.3 程式碼實現

public static Object[] selectSort(Object[] arr){
        //排除空異常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //從第一位元素開始確定
        for (int i = 0; i < arr.length - 1; i++) {
            //記錄當前獲得最小值的索引（取代實際交換操作）
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j].hashCode() < arr[min].hashCode()) {
                    min = j;
                }
            }
            sort(arr, i, min);
        }
        return arr;
    }

 結果：

四、插入排序

4.1 實現原理

將某一元素插入已經排序好的陣列中，

第一種：元素位於陣列右方，則元素依次與左方比較，找出合適位置，被比較元素後移一位，該元素前置

第二種：元素位於陣列左方，則元素依次與右方比較，找出合適位置，被比較元素前移一位，該元素後置

4.2 動圖解析

4.3 程式碼實現

private static Object[] insertSort(Object[] arr) {
        //排除空異常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //從第二位開始，比較元素前面的元素為排序好的陣列
        for (int i = 1; i < arr.length; i++) {
            Object temp = arr[i];
            //定義被比較陣列元素所在位
            int j = i - 1;
            while (j >= 0 && temp.hashCode() < arr[j].hashCode()) {
                arr[j + 1] = arr[j];
                j--;
            }
            //將插入元素前置
            arr[j + 1] = temp;
        }
        return arr;
    }

結果：

五、希爾排序

5.1 實現原理

按照一定間隔（記d）執行插入排序

第一種：元素位於陣列右方，記索引為x，則元素依次與左方x-d的元素比較，找出合適位置，被比較元素後移一位，該元素前置

第二種：元素位於陣列左方，記索引為x，則元素依次與右方x+d的元素比較，找出合適位置，被比較元素前移一位，該元素後置

5.2 動態解析

5.3 程式碼實現

private static Object[] shellSort(Object[] arr) {
        //排除空異常
        if (arr == null || arr.length == 0) {
            return arr;
        }
        //假定初始間隔為陣列長度二分之一，每次再乘以二分之一
        int len = arr.length / 2;

        while (len != 0) {
            for (int i = len; i < arr.length; i++) {
                Object temp = arr[i];
                //獲取與比較元素間隔len長度的陣列元素
                int j = i - len;
                //插入排序
                while (j >= 0 && (temp.hashCode() < arr[j].hashCode())) {
                    arr[j + len] = arr[j];
                    j = j - len;
                }
                arr[len + j] = temp;
            }
            len = len / 2;
        }
        return arr;
    }

結果：

更多詳細見解：https://blog.csdn.net/qq_35813653/article/details/83055078