Java排序算法（冒泡排序，选择排序，插入排序，希尔排序，快速排序，基数排序）

package com.example.dataStructureAndAlgorithm.sort;

import java.util.Arrays;

public class SortDemo {

    public static void main(String[] args) {
        // int[] arr = {3, 9, -1, 10, 20};
     //   int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        int[] arr={53, 3, 542, 748, 14, 214};
        System.out.println(Arrays.toString(arr));
        //     int[] arrSort=bubbleSort(arr);
        // int[] arrSort = selectSort(arr);
        //  int[] arrSort = insertSort(arr);
//        int[] arrSort = shellSort(arr);
        //     int[] arrSort = shellSort1(arr);
  //      quickSort(arr, 0, arr.length - 1);
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序
     *
     * @param arr
     * @return
     */
    public static int[] bubbleSort(int[] arr) {
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag) {
                flag = false;
            } else {
                break;
            }
        }
        return arr;
    }

    /**
     * 选择排序
     *
     * @param arr
     * @return
     */
    public static int[] selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int min = arr[i];//假定当前值是最小值
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {//说明假定的最小值不是最小
                    min = arr[j];//重置最小值和最小值index
                    minIndex = j;
                }
            }
            //找到最小值后，和当前值假定最小值交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
        return arr;
    }

    /**
     * 插入排序
     *
     * @param arr
     * @return
     */
    public static int[] insertSort(int[] arr) {
        int insertVal = 0;//待插入的值
        int insertIndex = 0;//待比较的值的下标
        for (int i = 1; i < arr.length; i++) {
            insertVal = arr[i];//当前值为待插入的值
            insertIndex = i - 1;//初始值和前一个值进行比较
            //insertIndex >= 0保证数值不越界
            //insertVal < arr[insertIndex] 待插入的数比待比较的值小，说明还没有找到插入位置，继续与insertIndex下标前一个的值比较
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // 当退出 while 循环时，说明插入的位置找到,是, insertIndex + 1，应该是插入到insertIndex后面
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
        return arr;
    }

    /**
     * 希尔排序
     *
     * @param arr
     * @return
     */
    public static int[] shellSort(int[] arr) {
        int temp = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j + gap];
                        arr[j + gap] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
        return arr;

    }

    /**
     * 希尔排序
     *
     * @param arr
     * @return
     */
    public static int[] shellSort1(int[] arr) {
        //增量gap,初始值为数组长度的一半，逐步减小增量，按增量将数组分成gap组，同一组内各个下标相隔距离等于增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            // 从第 gap 个元素，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++) {
                int insetVal = arr[i];//待插入的值
                int indexIndex;//待比较的值的下标，indexIndex = i - gap因为是按增量分组，所以是和同一组里的上一个即i-gap下标的值进行比较
                for (indexIndex = i - gap; indexIndex >= 0 && insetVal < arr[indexIndex]; indexIndex -= gap) {
                    //如果待插入的值小于待比较的值，则将待比较的值往后移一个位置（同组里），然后再与上上个值进行比较即indexIndex -= gap，以此类推
                    arr[indexIndex + gap] = arr[indexIndex];
                }
                //退出循环即代表找到插入的位置，插入的位置在index后面（同组内，数组则是后面gap个位置）
                arr[indexIndex + gap] = insetVal;
            }
        }
        return arr;
    }

    /**
     * 快速排序 在待排序的N个记录中任取一个元素(通常取第一个记录)作为基准，称为基准记录；
     * 定义两个索引 left 和 right 分别表示“首索引” 和 “尾索引”，key 表示“基准值”；
     * 首先，尾索引向前扫描，直到找到比基准值小的记录(left != righ)，并替换首索引对应的值；
     * 然后，首索引向后扫描，直到找到比基准值大于的记录(left != righ)，并替换尾索引对应的值；
     * 若在扫描过程中首索引等于尾索引(left = right),则一趟排序结束；将基准值(key)替换首索引所对应的值；
     * 再进行下一趟排序时，待排序列被分成两个区:[0,left-1],[righ+1,end]
     * 对每一个分区重复步骤2~6，直到所有分区中的记录都有序，排序成功。
     *
     * @param arr        待排序数组
     * @param leftIndex  起始位置
     * @param rightIndex 结束位置
     */
    public static void quickSort(int[] arr, int leftIndex, int rightIndex) {
        if (leftIndex >= rightIndex) {
            return;
        }
        int left = leftIndex;
        int right = rightIndex;
        int key = arr[left];//待排序的第一个元素作为基准值
        //从左右两边交替扫描，直到left = right
        while (left < right) {
            //先从右往左扫描，找到第一个比基准值小的元素
            while (right > left && arr[right] >= key) {
                right--;
            }
            //找到这个元素将arr[right]放入arr[left]中
            arr[left] = arr[right];
            //从左往右扫描，找到第一个比基准值大的元素
            while (right > left && arr[left] <= key) {
                left++;
            }
            //找到这个元素将arr[left]放入arr[right]中
            arr[right] = arr[left];
        }
        //基准值归位
        arr[left] = key;
        //对基准值左边的元素进行递归排序
        quickSort(arr, leftIndex, left - 1);
        //对基准值右边的元素进行递归排序。
        quickSort(arr, right + 1, rightIndex);
    }

    /**
     * 基数排序
     * @param arr
     */
    public static void radixSort(int[] arr) {
        //获取数组中最大的数的位数
        int maxNum = arr[0];
        for (int a : arr) {
            if (a > maxNum) {
                maxNum = a;
            }
        }
        int maxLength = (maxNum + "").length();
        //定义一个二维数组，每个一维数组代表一个桶，总共十个桶。每个桶里最多存放个数为arr的length
        int[][] radixArr = new int[10][arr.length];
        //定义一个一维数组，记录每个桶里的个数
        int[] radixCount = new int[10];
        //求个位%10，求十位/10%10，求百位/100%10，以此类推
        //最大的数有几位数则需要进行几轮排序
        for (int i = 0,n=1; i < maxLength; i++,n*=10) {
            for (int j = 0; j < arr.length; j++) {
                int num = arr[j]/n % 10;//取位数的值，将对应的数值放入相应的数的桶中
                radixArr[num][radixCount[num]] = arr[j];
                radixCount[num]++;//桶里个数加1
            }
            int index = 0;
            for (int k = 0; k < radixCount.length; k++) {
                if (radixCount[k] != 0) {//判断对应的桶里是否有值，有的话，取出桶里的值，按顺序放回到arr里面
                    for (int l = 0; l < radixCount[k]; l++) {
                        arr[index] = radixArr[k][l];
                        index++;
                    }
                }
                radixCount[k] = 0;//每轮结束后需要把radixCount[k] 重置为0
            }

        }
    }
}