十大排序算法（Java实现）

冒泡排序：

//冒泡排序
    public static int[] bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j + 1] < arr[j])
                    swap(arr, j, j + 1);
            }
        }
        return arr;
    }

选择排序：

//选择排序
    public static int[] selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[min] > arr[j]) min = j;
            }
            swap(arr, i, min);
        }
        return arr;
    }

插入排序：

//插入排序
public static int[] insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int j = i - 1;
            int temp = arr[i];
            while (j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
        return arr;
    }

希尔排序：

//希尔排序
public static int[] shellSort(int[] arr) {
        for (int i = arr.length / 2; i >= 1; i /= 2) {
            shell(arr, i);
        }
        return arr;
    }
    private static void shell(int[] arr, int k) {
        for (int i = k; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - k;
            while (j >= 0 && temp < arr[j]) {
                arr[j + k] = arr[j];
                j -= k;
            }
            arr[j + k] = temp;
        }
    }

归并排序：

//归并排序
public static int[] mergeSort(int[] arr) {
        if (arr.length < 2) return arr;
        int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length / 2);
        int[] arr2 = Arrays.copyOfRange(arr, arr.length / 2, arr.length);
        arr1 = mergeSort(arr1);
        arr2 = mergeSort(arr2);
        return combine(arr1, arr2);
    }
    private static int[] combine(int[] arr1, int[] arr2) {
        int[] arr = new int[arr1.length + arr2.length];
        for (int i = 0, j = 0, k = 0; k < arr.length; k++) {
            int temp;
            if (arr1.length <= i) temp = arr2[j++];
            else if (arr2.length <= j) temp = arr1[i++];
            else if (arr1[i] < arr2[j]) temp = arr1[i++];
            else temp = arr2[j++];
            arr[k] = temp;
        }
        return arr;
    }

快速排序：

//快速排序
public static int[] quickSort(int[] arr) {
        quickDoSort(arr, 0, arr.length - 1);
        return arr;
    }
    private static void quickDoSort(int[] arr, int left, int right) {
        if (left >= right) return;
        int partition = getPartition(arr, left, right);
        quickDoSort(arr, left, partition - 1);
        quickDoSort(arr, partition + 1, right);
    }
    private static int getPartition(int[] arr, int left, int right) {
        int index = left + 1;
        int target = arr[left];
        for (int i = left + 1; i <= right; i++) {
            if (target > arr[i]) {
                swap(arr, index, i);
                index++;
            }
        }
        swap(arr, index - 1, left);
        return index - 1;
    }

堆排序：

//堆排序
public static int[] heapSort(int[] arr) {
        int length = arr.length;
        //构建最大堆
        for (int i = (length - 1) / 2; i >= 0; i--) {
            adjust(arr, i, length);
        }
        while (length > 0) {
            swap(arr, 0, length - 1);
            length--;
            adjust(arr, 0, length);
        }
        return arr;
    }
    private static void adjust(int[] arr, int i, int length) {
        int l = i * 2 + 1;
        int r = i * 2 + 2;
        int max = i;
        if (length > l && arr[l] > arr[max]) max = l;
        if (length > r && arr[r] > arr[max]) max = r;
        if (max != i) {
            swap(arr, max, i);
            adjust(arr, max, length);
        }
    }

计数排序：

//计数排序
    public static int[] countingSort(int[] arr) {
        int min = arr[0], max = arr[0];
        for (int i : arr) {
            if (i > max) max = i;
            if (i < min) min = i;
        }
        int[] result = new int[max - min + 1];
        for (int i : arr) {
            result[i - min]++;
        }

        int j = 0;
        for (int i = 0; i < result.length; i++) {
            while (result[i] != 0) {
                arr[j++] = i;
                result[i]--;
            }
        }
        return arr;
    }

桶排序：

//桶排序
public static int[] bucketSort(int[] arr) {
        ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
        int min = arr[0], max = arr[0];
        for (int i : arr) {
            if (i > max) max = i;
            if (i < min) min = i;
        }
        int bucketNum = arr.length / 10;
        //初始化arr.length个空桶
        for (int i = 0; i < bucketNum; i++) {
            buckets.add(new ArrayList<Integer>());
        }
        for (int val : arr) {
            int index = (val - min) / ((max - min + 1) / bucketNum + 1);
            buckets.get(index).add(val);
        }
        for (int i = 0; i < bucketNum; i++) {
            Collections.sort(buckets.get(i));
        }
        int j = 0;
        for (int i = 0; i < bucketNum; i++) {
            for (int val : buckets.get(i)) {
                arr[j++] = val;
            }
        }
        return arr;
    }

基数排序：

版本一：

//基数排序(使用数组麻烦）
    public static int[] radixSort(int[] arr) {
        int max = arr[0];
        for (int num : arr) {
            if (max < num) max = num;
        }
        int times = (max + "").length();
        int[][] nums = new int[10][arr.length];
        //记录每个桶的索引
        int[] count = new int[10];
        for (int i = 0, n = 1; i < times; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                int ys = arr[j] / n % 10;
                nums[ys][count[ys]++] = arr[j];
            }
            int index = 0;
            for (int k = 0; k < 10; k++) {
                for (int j = 0; j < count[k]; j++) {
                    arr[index++] = nums[k][j];
                }
            }
            for (int j = 0; j < count.length; j++) {
                count[j] = 0;
            }
        }
        return arr;
    }

版本二：

 //基数排序2(使用list)
    public static int[] radixSort2(int[] arr) {
        int max = arr[0];
        for (int i : arr) {
            if (i > max) max = i;
        }
        int times = (max + "").length();
        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) list.add(new ArrayList<>());
        for (int i = 0, n = 1; i < times; i++, n *= 10) {

            for (int t = 0; t < arr.length; t++) {
                int ys = arr[t] / n % 10;
                list.get(ys).add(arr[t]);
            }
            int index = 0;
            for (int j = 0; j < list.size(); j++) {
                for (int k = 0; k < list.get(j).size(); k++) {
                    arr[index++] = list.get(j).get(k);
                }
            }

            for (List l : list) l.clear();
        }
        return arr;
    }