java基础进阶之数组排序-可能有你不知道的哦！！

已于 2023-12-06 19:53:59 修改
阅读量1.5k 收藏 23
点赞数 40
分类专栏： java基础进阶 文章标签： 算法 排序算法 数据结构 java算法
于 2023-12-06 19:41:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19343089/article/details/134834416
版权

1、使用Arrays类的sort方法

1.1、默认升序

        java中Arrays类提供了sort方法来进行快速排序，默认是升序的。

Arrays.sort(数组名)

private static void ArrSort1(int[] arr) {
        Arrays.sort(arr);
        System.out.println("快速排序-默认升序:"+Arrays.toString(arr));
    }

1.2、降序        

如果需要降序，写法如下：

//数组类型不能是基本数据类型

 Arrays.sort(数组名，Collections.reverseOrder())

private static void ArrSort2(int[] arr) {
        //数组类型不能是基本数据类型
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(arrayInteger, Collections.reverseOrder());
        System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));
    }

1.3、区间排序        

如果需要区间排序，写法如下：

//formIndex起始位置，toIndex结束位置

Arrays.sort(数组名,int formIndex, int toIndex)

private static void ArrSort3(int[] arr) {
        Arrays.sort(arr,1, 3);
        System.out.println("快速排序-区间排序:"+Arrays.toString(arr));
    }

1.4、重载排序

//数组类型不能是基本数据类型

Arrays.sort(数组名, new Comparator<数据类型对应的类>() {
    @Override
    public int compare(数据类型对应的类 o1, 数据类型对应的类 o2) {
        return 重载方式;
    }
});

private static void ArrSort4(int[] arr) {
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(arrayInteger, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
    }
    private static void ArrSort5(int[] arr) {
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        //lambda表达式
        Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);
        System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
    }

2、冒泡排序

        冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

        它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

        这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

2.1、原理

冒泡排序的原理如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.2、示例图

2.3、时间复杂度

2.4、稳定性

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

2.5、示例

   private static void ArrSortM(int[] arr) {
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序:"+Arrays.toString(arr));
    }
    private static void ArrSortM1(int[] arr) {
        // 初始时 swapped 为 true，否则排序过程无法启动
        boolean swapped = true;
        for (int i = 0; i < arr.length - 1; i++) {
            // 如果没有发生过交换，说明剩余部分已经有序，排序完成
            if (!swapped) break;
            // 设置 swapped 为 false，如果发生交换，则将其置为 true
            swapped = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 表示发生了交换
                    swapped = true;
                }
            }
        }
        System.out.println("冒泡排序1:"+Arrays.toString(arr));
    }

    private static void ArrSortM2(int[] arr) {
        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]) {
                    arr[j + 1] = arr[j + 1] + arr[j];
                    arr[j] = arr[j + 1] - arr[j];
                    arr[j + 1] = arr[j + 1] - arr[j];
                }
            }
        }
        System.out.println("冒泡排序2:"+Arrays.toString(arr));
    }
    private static void ArrSortM3(int[] arr) {
        boolean swapped = true;
        // 最后一个没有经过排序的元素的下标
        int indexOfLastUnsortedElement = arr.length - 1;
        // 上次发生交换的位置
        int swappedIndex = -1;
        while (swapped) {
            swapped = false;
            for (int i = 0; i < indexOfLastUnsortedElement; i++) {
                if (arr[i] > arr[i + 1]) {
                    // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    // 表示发生了交换
                    swapped = true;
                    // 更新交换的位置
                    swappedIndex = i;
                }
            }
            // 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置
            indexOfLastUnsortedElement = swappedIndex;
        }
        System.out.println("冒泡排序3:"+Arrays.toString(arr));
    }

3、选择排序

3.1、原理

选择排序：通过不断选择数组中最小的元素，并将其放置在已排序部分的末尾，逐渐构建有序数组。

 3.2、示例图

 

3.3、时间复杂度

        选择排序的交换操作介于 0 和 (n - 1)次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1） 次之间。比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

3.4、稳定性

        选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

3.5、二元选择排序

        二元选择排序，每轮选择时记录最小值和最大值，可以把选择排序的效率提升一点，由于每一轮遍历可以排好两个数字，所以最外层的遍历只需遍历一半即可。

        经过优化之后，选择排序的效率提升了一点。但可惜的是，这样的优化无法改变时间复杂度，我们知道时间复杂度与常量系数无关，仍然是 O(n^2)。

3.6、示例

    private static void ArrSortX(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        System.out.println("选择排序:"+ Arrays.toString(arr));
    }
    private static void ArrSortX1(int[] arr) {
        int minIndex, maxIndex;
        // i 只需要遍历一半
        for (int i = 0; i < arr.length / 2; i++) {
            minIndex = i;
            maxIndex = i;
            for (int j = i + 1; j < arr.length - i; j++) {
                if (arr[minIndex] > arr[j]) {
                    // 记录最小值的下标
                    minIndex = j;
                }
                if (arr[maxIndex] < arr[j]) {
                    // 记录最大值的下标
                    maxIndex = j;
                }
            }
            // 将最小元素交换至首位
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
            // 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。
            if (maxIndex == i) maxIndex = minIndex;
            // 将最大元素交换至末尾
            int lastIndex = arr.length - 1 - i;
            temp = arr[lastIndex];
            arr[lastIndex] = arr[maxIndex];
            arr[maxIndex] = temp;
        }
        System.out.println("选择排序1:"+ Arrays.toString(arr));
    }

4、插入排序

4.1、原理

        插入排序的思想非常简单，生活中有一个非常常见的场景：在打扑克牌时，我们一边抓牌一边给扑克牌排序，每次摸一张牌，就将它插入手上已有的牌中合适的位置，逐渐完成整个排序。

4.2、示例图

4.3、时间复杂度

        在插入排序中，当待排序数组是有序时，是最优的情况，只需当前数跟前一个数比较一下就可以了，这时一共需要比较N- 1次，时间复杂度为O(N)  

        最坏的情况是待排序数组是逆序的，此时需要比较次数最多，总次数记为：1+2+3+…+N-1，所以，插入排序最坏情况下的时间复杂度为0(N*N)

        平均来说，A[1..j-1]中的一半元素小于A[j]，一半元素大于A[j]。插入排序在平均情况运行时间与最坏情况运行时间一样，是输入规模的二次函数。

4.4、稳定性

        如果待排序的序列中存在两个或两个以上具有相同关键词的数据，排序后这些数据的相对次序保持不变，即它们的位置保持不变，通俗地讲，就是两个相同的数的相对顺序不会发生改变，则该算法是稳定的；如果排序后，数据的相对次序发生了变化，则该算法是不稳定的。关键词相同的数据元素将保持原有位置不变，所以该算法是稳定的。

4.5、示例

    private static void ArrSortC(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

5、快速排序

        通过选择一个基准元素，将数组分成两部分，一部分小于基准元素，一部分大于基准元素，然后递归地对两部分进行排序。示例代码如下：

    private static void ArrSortK(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            ArrSortK(arr, low, pivotIndex - 1);
            ArrSortK(arr, pivotIndex + 1, high);
        }
        System.out.println("快速排序:"+Arrays.toString(arr));
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

6、归并排序

        通过将数组分成两部分，分别对两部分进行排序，然后将两个有序的部分合并成一个有序数组。示例代码如下：

   private static void ArrSortG(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            ArrSortG(arr, low, mid);
            ArrSortG(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
        System.out.println("归并排序:"+Arrays.toString(arr));
    }
    private static void merge(int[] array, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high) {
            if (array[i] <= array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = array[i++];
        }
        while (j <= high) {
            temp[k++] = array[j++];
        }
        for (int m = 0; m < temp.length; m++) {
            array[low + m] = temp[m];
        }
    }

 整体代码

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class TestArray2 {
    public static void main(String[] args) {
        int[] arr = {3, 2, 1, 5, 4};
        System.out.println("arr:"+Arrays.toString(arr));
        //输出方式
        //extracted(arr);

        //方法一：快速排序
        ArrSort1(arr);
//        ArrSort2(arr);
//        ArrSort3(arr);
//        ArrSort4(arr);
//        ArrSort5(arr);

        //方法二：冒泡方法
//        ArrSortM(arr);
//        ArrSortM1(arr);
//        ArrSortM2(arr);
//        ArrSortM3(arr);

        //方法三：选择排序
//        ArrSortX(arr);
//        ArrSortX1(arr);

        //方法四：插入排序
//        ArrSortC(arr);

        //方法五：快速排序
//        ArrSortK(arr,0,arr.length-1);

         //方法六：归并排序
//        ArrSortG(arr,0,arr.length-1);

    }

    private static void ArrSortG(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            ArrSortG(arr, low, mid);
            ArrSortG(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
        System.out.println("归并排序:"+Arrays.toString(arr));
    }
    private static void merge(int[] array, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high) {
            if (array[i] <= array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = array[i++];
        }
        while (j <= high) {
            temp[k++] = array[j++];
        }
        for (int m = 0; m < temp.length; m++) {
            array[low + m] = temp[m];
        }
    }

    private static void ArrSortK(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            ArrSortK(arr, low, pivotIndex - 1);
            ArrSortK(arr, pivotIndex + 1, high);
        }
        System.out.println("快速排序:"+Arrays.toString(arr));
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    private static void ArrSortC(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    private static void ArrSortX(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        System.out.println("选择排序:"+ Arrays.toString(arr));
    }
    private static void ArrSortX1(int[] arr) {
        int minIndex, maxIndex;
        // i 只需要遍历一半
        for (int i = 0; i < arr.length / 2; i++) {
            minIndex = i;
            maxIndex = i;
            for (int j = i + 1; j < arr.length - i; j++) {
                if (arr[minIndex] > arr[j]) {
                    // 记录最小值的下标
                    minIndex = j;
                }
                if (arr[maxIndex] < arr[j]) {
                    // 记录最大值的下标
                    maxIndex = j;
                }
            }
            // 将最小元素交换至首位
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
            // 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。
            if (maxIndex == i) maxIndex = minIndex;
            // 将最大元素交换至末尾
            int lastIndex = arr.length - 1 - i;
            temp = arr[lastIndex];
            arr[lastIndex] = arr[maxIndex];
            arr[maxIndex] = temp;
        }
        System.out.println("选择排序1:"+ Arrays.toString(arr));
    }

    private static void ArrSortM(int[] arr) {
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序:"+Arrays.toString(arr));
    }
    private static void ArrSortM1(int[] arr) {
        // 初始时 swapped 为 true，否则排序过程无法启动
        boolean swapped = true;
        for (int i = 0; i < arr.length - 1; i++) {
            // 如果没有发生过交换，说明剩余部分已经有序，排序完成
            if (!swapped) break;
            // 设置 swapped 为 false，如果发生交换，则将其置为 true
            swapped = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 表示发生了交换
                    swapped = true;
                }
            }
        }
        System.out.println("冒泡排序1:"+Arrays.toString(arr));
    }

    private static void ArrSortM2(int[] arr) {
        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]) {
                    arr[j + 1] = arr[j + 1] + arr[j];
                    arr[j] = arr[j + 1] - arr[j];
                    arr[j + 1] = arr[j + 1] - arr[j];
                }
            }
        }
        System.out.println("冒泡排序2:"+Arrays.toString(arr));
    }
    private static void ArrSortM3(int[] arr) {
        boolean swapped = true;
        // 最后一个没有经过排序的元素的下标
        int indexOfLastUnsortedElement = arr.length - 1;
        // 上次发生交换的位置
        int swappedIndex = -1;
        while (swapped) {
            swapped = false;
            for (int i = 0; i < indexOfLastUnsortedElement; i++) {
                if (arr[i] > arr[i + 1]) {
                    // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    // 表示发生了交换
                    swapped = true;
                    // 更新交换的位置
                    swappedIndex = i;
                }
            }
            // 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置
            indexOfLastUnsortedElement = swappedIndex;
        }
        System.out.println("冒泡排序3:"+Arrays.toString(arr));
    }

    private static void ArrSort1(int[] arr) {
        Arrays.sort(arr);
        System.out.println("快速排序-默认升序:"+Arrays.toString(arr));
    }
    private static void ArrSort2(int[] arr) {
        //数组类型不能是基本数据类型
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(arrayInteger, Collections.reverseOrder());
        System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));
    }
    private static void ArrSort3(int[] arr) {
        Arrays.sort(arr,1, 3);
        System.out.println("快速排序-区间排序:"+Arrays.toString(arr));
    }
    private static void ArrSort4(int[] arr) {
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(arrayInteger, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
    }
    private static void ArrSort5(int[] arr) {
        Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        //lambda表达式
        Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);
        System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));
    }

    private static void extracted(int[] arr) {
        System.out.println("原来的数组:"+ arr);
        //输出方式-for
        System.out.println("输出方式-for:");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("for循环输出:"+ arr[i]);
        }
        System.out.println("======================");
        //输出方式-for each
        System.out.println("输出方式-for each:");
        for (int i: arr){
            System.out.println("for each循环输出:"+i);
        }
        System.out.println("======================");
        //输出方式1-toString
        System.out.println("输出方式-toString:");
        System.out.println("toString:"+Arrays.toString(arr));
        System.out.println("======================");
    }

}
清爽的暗之妖刀0369
关注
  • 40
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 程序对数组元素进行降序排序
我的博客，不一样的自我表达
07-26 2918
时间复杂度： O(N 2 ) 在 Java 14 之前，Arrays.sort(int[]) 使用双枢轴快速排序，最坏情况复杂度为 O(N 2 )。通过将数组和 Collections.reverseOrder() 作为参数传递给 Arrays.sort()，可以对数组元素进行降序排序。输入：数组 = {2, 6, 23, 98, 24, 35, 78}输出： [98, 78, 35, 24, 23, 6, 2]输入：数组 = {1, 2, 3, 4, 5}输出： [5, 4, 3, 2, 1]
java基础之数组排序
qq_45903614的博客
05-18 121
java基础之数组排序冒泡排序选择排序sort排序 概念理解 时间复杂度： 在程序中寻找一段必然会执行的代码，将这段代码的执行时间认为是单位1，执行这个单位1需要的次数就是时间复杂度，时间复杂度不考虑系数，一般来说找最高阶。 空间复杂度： 这段程序执行所需要额外耗费的空间就是空间复杂度。 时间复杂度与空间复杂度都要满足O(n^x)、O((logn) ^x)、O(n ^y(logn) ^x)这三种形式之一。 冒泡排序 原理（升序）： 依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1
Java中的升序和降序
m0_54185237的博客
08-19 7898
comparator接口只能使用引用元素进行排序，在该接口比较器中，当进行升序排序时，如果认为左边数据大于右边数据则返回正整数，右边大于左边返回负整数，相等返回0，这样就能进行一个完整的升序排序操作。降序排序则反之，左>右为返回负整数，以此类推。而我们的comparator还有一种简便方法来进行排序操作，即无需在该接口中进行if语句的判断，而是将两个值直接相减，以此来判断正负值。
Java数组排序的方法
热门推荐
qf2019的博客
07-29 2万+
1.快速排序：首先是最简单的Array.sort，直接进行排序： public static void main(String[] args) { int[] arr = {4,3,5,1,7,9,3}; Arrays.sort(arr); for (int i : arr){ System.out.println(i); } 点击运行即可输出已排序的数组数字。 2.部分排序法：使用Array.sort
经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】
最新发布
2401_85112052的博客
05-28 924
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）**该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）**
Java—常见数组排序方法
qq_44495081的博客
10-30 8865
文章目录一、数组排序1. 冒泡排序2. 选择排序3. 二分查找4. 快速排序5. 插入排序6. 归并排序 一、数组排序 1. 冒泡排序 原理 从第一个元素开始，两两进行比较，将较大的数往后移，这样就将最大的数放在了最后。第二轮将第二大的数放在倒数第二个，以次类推，将元素按大小顺序排序 图示 代码实现 /** * 利用冒泡排序法对数组进行排序 */ pub...
Java排序，看这一篇就够了（List、Map、Object复合升序和降序）
西凉的悲伤博客
09-09 1万+
Java排序，看这一篇就够了（List、Map、Object复合升序和降序）
Java基础和Java进阶
10-16
深入理解Java的基础和进阶知识对于成为一位熟练的Java开发者至关重要。本文将详细介绍Java中的JUnit使用流程、集合框架及其进阶、Stream流、多线程、IO流等关键概念。 一、JUnit使用流程 JUnit是一个用于Java编程...
Java基础，Java进阶，Java数据结构，十大算法
04-04
接下来是“Java进阶”部分，这部分将深入探讨更多高级特性： 1. **多线程**：Java提供的Thread类和Runnable接口，线程同步机制（synchronized关键字、wait/notify、Lock锁）以及并发工具类。 2. **网络编程**：套...
java进阶（文件读写、递归、数组排序、单体工厂模式）
10-04
数组排序是数据结构和算法中的基础。Java提供了多种排序方法，如冒泡排序、选择排序、插入排序、快速排序、归并排序等。其中，`Arrays.sort()`方法是Java内置的通用排序函数，它可以对对象数组和基本类型数组进行...
java代码-java 选择排序 进阶版 Max Min同时进行
07-15
在Java编程中，选择排序是一种基础的排序算法，它的进阶版通常指的是在原基础上进行优化或改进，以提高效率或解决特定问题。在这个场景中，“Max Min同时进行”可能是指在一次遍历中找到数组中的最大值（Max）和...
JAVA入门学习 —数组排序的方法
weixin_67614925的博客
04-20 2万+
目录1.冒泡排序(Bubble Sort)2.选择排序(Select Sort)3.插入排序(Insert Sort)4.希尔排序(Shell Sort)5.快速排序(Quick Sort)6.归并排序(Merge Sort)7.堆排序(Heap Sort)8.计数排序 (Count Sort)9.桶排序(Bucket Sort)10.基数排序(Raix Sort) 1.冒泡排序(Bubble Sort) 冒泡排序的思想：       &nbs
java升序和降序代码
qq_28514075的博客
12-26 600
【代码】java升序和降序代码。
Java基础——Arrays类的排序方法
weixin_61275790的博客
04-06 1387
public static void sort(类型[] a, Comparator
Java中常见的几种数组排序方法
weixin_61930152的博客
05-06 1万+
这篇文章总结一下我学习到的几种常见的数组排序方法，包括冒泡排序、插入排序、快速排序等等
Java中常用的数组排序算法
天天++的博客
02-07 1371
Java中常用的数组排序算法：冒泡排序，选择排序，插入排序，希尔排序，归并排序，快速排序
Java数组快速排序
fmz2222的博客
05-11 1312
/调用方法进行排序，即Arrays.sort()。//数组中从I开始取最小值的位置的索引是tem，用这个索引交换第I位上的元素。Arrays.sort()排序方法是java中最简单也是最常用的排序方法。//将数组第I位的元素与arr.length-i-1位的元素交换。If (arr5[j-1] arr5[j]) {//把大的放后面。找到最小元素所在的索引，然后用第一个位置的元素交换元素。i arr5 .长度；//array[]是要排序的数组，n是数组长度。//指定从I到tem开始的数组中最小元素的索引。
JAVA数组与排序(数组的排序)
VisionLau的博客
03-12 3384
排序 数据的学习就已经结束了，现在我们来学习对数据排序的算法 正式开始！ 冒泡排序 现在我们给定一个无序的int的数组，如下 int arr[]={23,45,2,66,87,44}; 我们要求将上面数组的元素从小到大的升序排列，要求结果如下 {2,23,44,45,66,87} 那么我们要怎么实现呢?我们就来学习第一个算法-----冒泡排序法 实现思路 冒泡排序法的实现思路就是将两个元素进行比较，大的往后移一位，这样通过几轮比较，就可以实现对数组的排序了 画图分析 我们来简单画个图 第一轮
java——数组排序（升序和降序排列）
qq_67308046的博客
06-10 1万+
数组排序（升序和降序排列）
练习-java数组之arrays类操作数组之数组排序
06-28
### 回答1： Java中的Arrays类提供了许多操作数组的方法，其中包括对数组进行排序的方法。使用Arrays.sort()方法可以对数组进行排序，该方法可以对任何类型的数组进行排序，包括基本类型和对象类型。 例如，对一个整型数组进行排序，可以使用以下代码： int[] arr = {5, 2, 8, 1, 9}; Arrays.sort(arr); 排序后，数组arr的值为{1, 2, 5, 8, 9}。 如果要对一个字符串数组进行排序，可以使用以下代码： String[] arr = {"apple", "banana", "orange", "pear"}; Arrays.sort(arr); 排序后，数组arr的值为{"apple", "banana", "orange", "pear"}。 需要注意的是，Arrays.sort()方法会改变原始数组的顺序，如果需要保留原始数组的顺序，可以先将数组复制一份再进行排序。 ### 回答2： Java数组是一种很常见的数据类型，在实际开发中使用频率也很高。在Java中，对于数组的操作一般使用Arrays类来完成，该类提供了很多实用的方法，比如数组排序等。 数组排序是对数组中的元素进行排序的过程，可以按照升序或者降序排列。Java中使用Arrays类提供的sort方法对数组进行排序，方法的原型如下: public static void sort(数组名); 其中，数组名代表需要排序的数组。如果数组中的元素为基本数据类型（如int、double等），则默认按照升序排列；如果数组中的元素为字符串类型，则按照字典序升序排列。 下面是一个示例代码，演示如何使用Arrays类对数组进行排序： ``` import java.util.Arrays; public class ArraySortDemo { public static void main(String[] args) { int[] nums = {3, 7, 1, 9, 5}; System.out.println("排序前：" + Arrays.toString(nums)); Arrays.sort(nums); System.out.println("排序后：" + Arrays.toString(nums)); } } ``` 代码执行结果如下： ``` 排序前：[3, 7, 1, 9, 5] 排序后：[1, 3, 5, 7, 9] ``` 可以看到，排序前的数组为3、7、1、9、5，排序后的数组为1、3、5、7、9，按照升序排列。 除了按照升序排列之外，还可以按照降序排列。可以使用Arrays类的sort方法，同时指定排序算法和排序方式，如下所示： ``` import java.util.Arrays; import java.util.Collections; public class ArraySortDemo { public static void main(String[] args) { Integer[] nums = {3, 7, 1, 9, 5}; System.out.println("排序前：" + Arrays.toString(nums)); Arrays.sort(nums, Collections.reverseOrder()); System.out.println("排序后：" + Arrays.toString(nums)); } } ``` 代码执行结果如下： ``` 排序前：[3, 7, 1, 9, 5] 排序后：[9, 7, 5, 3, 1] ``` 可以看到，本次使用了Collections类提供的reverseOrder方法，将排序方式指定为降序。 综上所述，通过Arrays类提供的sort方法，我们可以很轻松地对数组进行排序。但是需要注意的是，如果数组中的元素为自定义类型，需要在自定义类型中实现Comparable接口或者Comparator接口，并重写compareTo方法或compare方法，才能实现对数组的排序。 ### 回答3： Java中自带了一个Arrays类，其中包含了对数组排序的方法。Arrays类中的sort()方法可以以升序或降序的形式对数组进行排序。下面就介绍一下如何使用sort()方法对数组进行排序。 首先，我们创建一个数组，然后使用sort()方法对其进行排序。 ``` int[] arr = {10, 5, 8, 20, 13}; Arrays.sort(arr); ``` 上面的代码会将数组arr按照从小到大的顺序进行排序。我们可以输出一下排序后的结果。 ``` for (int i : arr) { System.out.print(i + " "); } ``` 运行上面的代码可以看到输出结果为：5 8 10 13 20。 除了按照从小到大的顺序排序外，sort()方法还可以按照从大到小的顺序对数组进行排序。我们只需要添加一个比较器即可。 ``` int[] arr2 = {10, 5, 8, 20, 13}; Arrays.sort(arr2, Collections.reverseOrder()); ``` 上面的代码会将数组arr2按照从大到小的顺序进行排序。我们同样输出一下排序后的结果。 ``` for (int i : arr2) { System.out.print(i + " "); } ``` 运行上面的代码可以看到输出结果为：20 13 10 8 5。 除了对int类型的数组进行排序，sort()方法也支持对其他类型的数组进行排序，比如String、Double等。 总的来说，使用Arrays类中的sort()方法可以非常方便地对数组进行排序，提高我们的开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清爽的暗之妖刀0369

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值