排序算法整理（java）

import com.alibaba.fastjson.JSON;

import java.util.function.Function;
import java.util.stream.IntStream;

/**
 * @Description:
 * @Author: chenweipeng
 * @Date: 2023/11/1 13:32
 */
public class IntSortUtil {

    public static void main(String[] args) {
        int[] arr = new int[]{6, 2, 5, 9, 3, 8, 4, 1, 10, 7};
        streamSort(arr, true);
        System.out.println(JSON.toJSONString(arr));

        arr = new int[]{6, 2, 5, 9, 3, 8, 4, 1, 10, 7};
        streamSort(arr, false);
        System.out.println(JSON.toJSONString(arr));

    }

    /**
     * 交换数组元素
     *
     * @param arr
     * @param i
     * @param j
     */
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * java排序
     *
     * @param arr
     * @param isAsc
     */
    public static void streamSort(int[] arr, boolean isAsc) {
        int[] tempArr = IntStream.of(arr).sorted().toArray();
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            if (isAsc) {
                arr[i] = tempArr[i];
            } else {
                arr[i] = tempArr[n - i - 1];
            }
        }
    }

    /**
     * 冒泡排序
     * 时间复杂度：最好：O(n)最坏：O(n^2)平均：O(n^2)
     * 空间复杂度：O(1)
     * 稳定性：稳定
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (isAsc) {
                    if (arr[j + 1] < arr[j]) {
                        swap(arr, j + 1, j);
                    }
                } else {
                    if (arr[j + 1] > arr[j]) {
                        swap(arr, j + 1, j);
                    }
                }
            }
        }
    }

    /**
     * 插入排序
     * 时间复杂度：最好：O(n)最坏：O(n^2)平均：O(n^2)
     * 空间复杂度：O(1)
     * 稳定性：稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void insertSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = i; j > 0; j--) {
                if (isAsc) {
                    if (arr[j] < arr[j - 1]) {
                        swap(arr, j, j - 1);
                    }
                } else {
                    if (arr[j] > arr[j - 1]) {
                        swap(arr, j, j - 1);
                    }
                }
            }
        }
    }

    /**
     * 直接选择排序
     * 时间复杂度：最好：O(n^2)最坏：O(n^2)平均：O(n^2)
     * 空间复杂度：O(1)
     * 稳定性：不稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void selectSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int index = i;
            for (int j = i + 1; j < n; j++) {
                if (isAsc) {
                    if (arr[j] < arr[index]) {
                        index = j;
                    }
                } else {
                    if (arr[j] > arr[index]) {
                        index = j;
                    }
                }
            }
            if (index != i) {
                swap(arr, index, i);
            }
        }
    }

    /**
     * 希尔排序
     * 时间复杂度：最好：O(n)最坏：O(n^2)平均：O(n^1.3)
     * 空间复杂度：O(1)
     * 稳定性：不稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void shellSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        for (int gap = n / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < n; i++) {
                int j;
                int temp = arr[i];
                if (isAsc) {
                    for (j = i; j >= gap && temp < arr[j - gap]; j -= gap) {
                        arr[j] = arr[j - gap];
                    }
                    if (i != j) {
                        arr[j] = temp;
                    }
                } else {
                    for (j = i; j >= gap && temp > arr[j - gap]; j -= gap) {
                        arr[j] = arr[j - gap];
                    }
                    if (i != j) {
                        arr[j] = temp;
                    }
                }
            }
        }
    }


    /**
     * 快速排序
     * 时间复杂度：最好：O(nlog2n)最坏：O(n^2)平均：O(nlog2n)
     * 空间复杂度：O(nlog2n)
     * 稳定性：不稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void quickSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        quickSortInner(arr, isAsc, 0, n - 1);
    }

    private static void quickSortInner(int[] arr, boolean isAsc, int low, int height) {
        if (low >= height) {
            return;
        }
        int l = low;
        int r = height;
        int pivot = arr[low];
        while (l < r) {
            if (isAsc) {
                while (l < r && arr[r] >= pivot) {
                    r--;
                }
                while (l < r && arr[l] <= pivot) {
                    l++;
                }
            } else {
                while (l < r && arr[r] <= pivot) {
                    r--;
                }
                while (l < r && arr[l] >= pivot) {
                    l++;
                }
            }
            if (l < r) {
                swap(arr, l, r);
            }
        }
        arr[low] = arr[l];
        arr[l] = pivot;
        if (low < l) {
            quickSortInner(arr, isAsc, low, l - 1);
        }
        if (height > r) {
            quickSortInner(arr, isAsc, r + 1, height);
        }
    }


    /**
     * 堆排序
     * 时间复杂度：最好：O(nlog2n)最坏：O(nlog2n)平均：O(nlog2n)
     * 空间复杂度：O(1)
     * 稳定性：不稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void heapSort(int[] arr, boolean isAsc) {
        int n = arr.length;
        for (int i = (n - 1) / 2; i >= 0; i--) {
            maxHeap(arr, isAsc, n, i);
        }

        for (int i = n - 1; i > 0; i--) {
            swap(arr, 0, i);
            maxHeap(arr, isAsc, i, 0);
        }
    }

    private static void maxHeap(int[] arr, boolean isAsc, int size, int index) {
        int left = 2 * index;
        int right = 2 * index + 1;
        int temp = index;
        if (isAsc) {
            if (left < size && arr[left] > arr[temp]) {
                temp = left;
            }
            if (right < size && arr[right] > arr[temp]) {
                temp = right;
            }
        } else {
            if (left < size && arr[left] < arr[temp]) {
                temp = left;
            }
            if (right < size && arr[right] < arr[temp]) {
                temp = right;
            }
        }
        if (temp != index) {
            swap(arr, index, temp);
            maxHeap(arr, isAsc, size, temp);
        }
    }

    /**
     * 归并排序
     * 时间复杂度：最好：O(nlog2n)最坏：O(nlog2n)平均：O(nlog2n)
     * 空间复杂度：O(n)
     * 稳定性：稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void mergeSort(int[] arr, boolean isAsc) {
        mergeSortInner(arr, isAsc, 0, arr.length - 1);
    }

    private static void mergeSortInner(int[] arr, boolean isAsc, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSortInner(arr, isAsc, left, mid);
            mergeSortInner(arr, isAsc, mid + 1, right);
            merge(arr, isAsc, left, mid, right);
        }
    }

    private static void merge(int[] arr, boolean isAsc, int left, int mid, int right) {
        int n = arr.length;
        int[] tempArr = new int[n];
        for (int i = 0; i < n; i++) {
            tempArr[i] = arr[i];
        }
        int l = left, index = left;
        int r = mid + 1;
        for (; l <= mid && r <= right && index <= right; index++) {
            if (isAsc) {
                if (tempArr[l] < tempArr[r]) {
                    arr[index] = tempArr[l++];
                } else {
                    arr[index] = tempArr[r++];
                }
            } else {
                if (tempArr[l] > tempArr[r]) {
                    arr[index] = tempArr[l++];
                } else {
                    arr[index] = tempArr[r++];
                }
            }
        }
        while (l <= mid) {
            arr[index++] = tempArr[l++];
        }
        while (r <= right) {
            arr[index++] = tempArr[r++];
        }
    }

    /**
     * 基数排序
     * 时间复杂度：最好：O(d(n+rd))最坏：O(d(r+n))平均：O(d(r+n))
     * 空间复杂度：O(rd+n)
     * 稳定性：稳定
     *
     * @param arr
     * @param isAsc
     */
    public static void radixSort(int[] arr, boolean isAsc) {
        int max = IntStream.of(arr).max().getAsInt();
        for (int rad = 1; max / rad > 0; rad *= 10) {
            radixSortInner(arr, isAsc, rad);
        }
        if (!isAsc) {
            for (int i = 0; i <= arr.length / 2; i++) {
                if (i != arr.length - i - 1) {
                    swap(arr, i, arr.length - i - 1);
                }
            }
        }
    }

    private static void radixSortInner(int[] arr, boolean isAsc, int rad) {
        int n = arr.length;
        int[] bucketArr = new int[10];
        int[] tempArr = new int[n];

        Function<Integer, Integer> getIndex = (i) -> (arr[i] / rad) % 10;

        for (int i = 0; i < n; i++) {
            bucketArr[getIndex.apply(i)]++;
        }
        for (int i = 1; i < 10; i++) {
            bucketArr[i] += bucketArr[i - 1];
        }
        for (int i = n - 1; i >= 0; i--) {
            tempArr[bucketArr[getIndex.apply(i)] - 1] = arr[i];
            bucketArr[getIndex.apply(i)]--;
        }
        for (int i = 0; i < n; i++) {
            arr[i] = tempArr[i];
        }
    }


}