java常用的几种排序方法

一、冒泡排序

// 使用冒泡排序算法对数字进行降序排序
        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = 0; j < numbers.length - i - 1; j++) {
                // 如果当前数字小于下一个数字，则交换它们
                if (numbers[j] < numbers[j + 1]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        

二、直接选择排序

 // 使用直接选择排序算法从大到小排序
        for (int i = 0; i < numbers.length - 1; i++) {
            int maxIndex = i;
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] > numbers[maxIndex]) {
                    maxIndex = j;
                }
            }
            // 交换当前元素和找到的最大元素
            int temp = numbers[i];
            numbers[i] = numbers[maxIndex];
            numbers[maxIndex] = temp;
        }

三、插入排序

public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        // 将大于key的元素向右移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

四、希尔排序

public static void shellSort(int[] arr) {
    int n = arr.length;
    int gap = n / 2;

    // 希尔排序的循环
    while (gap > 0) {

        // 插入排序的循环
        for (int i = gap; i < n; i++) {

            // 添加 arr[i] 到 arr[0..i-gap] 的已排序序列中
            int temp = arr[i];

            // 将元素插入到正确的位置
            for (int j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
        gap /= 2;
    }
}

五、归并排序

public class MergeSortDescending {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2, 7, 1, 6, 9, 0};
        mergeSortDescending(arr, 0, arr.length - 1);
        System.out.println("排序后的数组（降序）: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void mergeSortDescending(int[] arr, int left, int right) {
        if (left < right) {
            // 找到中间点
            int mid = (left + right) / 2;
            // 对左半部分进行归并排序
            mergeSortDescending(arr, left, mid);
            // 对右半部分进行归并排序
            mergeSortDescending(arr, mid + 1, right);
            // 合并两个已排序的半部分
            merge(arr, left, mid, right);
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        // 临时数组，用于存放合并后的结果
        int[] temp = new int[right - left + 1];
        // 初始化索引
        int i = left, j = mid + 1, k = 0;

        // 从两个有序数组中取出元素，按降序放入临时数组
        while (i <= mid && j <= right) {
            if (arr[i] >= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        // 将左边剩余的元素放入临时数组
        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        // 将右边剩余的元素放入临时数组
        while (j <= right) {
            temp[k++] = arr[j++];
        }

        // 将临时数组中的元素复制回原数组
        while (k > 0) {
            arr[left + k - 1] = temp[k - 1];
            k--;
        }
    }
}