​排序算法大体可分为两种：
1、比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
2、非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

先定义个交换数组元素的函数，供排序时调用

/**
     * 交换数组元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a,int b){
        arr[a] = arr[a]+arr[b];
        arr[b] = arr[a]-arr[b];
        arr[a] = arr[a]-arr[b];
    }

冒泡排序

注意写循环的时候 一般都是0开始，这里数组下标是从0开始所以for循环也是从0开始递增

总结：
至于升序还是降序换下比较条件即可实现，这里以升序为例说明比较规则
冒泡排序就是相邻两个元素反复比较，把大的值不停的往后移(右移)
这个的结果就是我会确定一个最大的值移动到最右侧，那要比较多少次才能移到最右侧，自然是数组长度-1。
上面每个回合都会排好一个最大的，所以我们下次比较次数就不用比那些排好序的了 即比较 数组长度-减去比较次数 - 1

 public static void main(String[] args) {
        Random random = new Random();
        int arrayLength = 10;
        int[] arr = new int[arrayLength];
        for (int i = 0; i < arrayLength; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

优化：

选择排序

    public static void main(String[] args) {
        Random random = new Random();
        int arrayLength = 10;
        int[] arr = new int[arrayLength];
        for (int i = 0; i < arrayLength; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arrayLength - 1; i++) {
            for (int j = i + 1; j < arrayLength; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

优化：

插入排序(抓牌)

排序原理

    public static void main(String[] args) {
        Random random = new Random();
        int arrayLength = 20;
        int[] arr = new int[arrayLength];
        for (int i = 0; i < arrayLength; i++) {
            arr[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 1; i < arrayLength; i++) {
            int j = i;
            while (j > 0) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                    j--;
                }else {
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

/**
     * 插入排序
     *
     * @param arr
     */
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                swap(arr,j,j-1);
                j--;
            }
        }
    }

希尔排序

上次 间隔 5-1 = 4

归并排序