滚雪球学Java(29)：数组长度和排序算法：让你的程序更高效

---

🏆本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，助你一臂之力，带你早日登顶🚀，欢迎大家关注&&收藏！持续更新中，up！up！up！！

---

前言

  在上一篇文章中，我们学习了数组的常用技巧和方法。本篇文章将深入探讨数组长度以及如何使用排序算法提高程序效率。在深入理解了数组的基本概念和操作后，我们将继续探索Java数组的深度应用，特别是数组长度的管理和排序算法的实现。这些知识将帮助我们更有效地处理数据集合，优化我们的程序性能。

摘要

  本文将深入探讨数组长度的概念及其在Java中的使用，同时介绍几种常用的排序算法，包括冒泡排序、选择排序和快速排序。通过实际的代码示例，我们将展示如何实现这些算法，并讨论它们的效率和适用场景。

1. 数组长度是数组中元素的个数，可以使用 length 属性获取。
2. 排序算法可用于将数组按升序或降序排列。
3. 常用的排序算法有冒泡排序、选择排序和快速排序。
4. 排序算法的效率取决于数据规模和算法实现。

Java数组

数组长度

  数组长度是确定数组容量的关键属性。在Java中，一旦数组被创建，其长度就不能改变。如果需要调整数组大小，我们必须创建一个新的数组并复制现有元素。理解数组长度的概念对于数组管理和内存使用至关重要。

int[] arr = {1, 2, 3, 4, 5};
int length = arr.length; // 5

  需要注意的是，数组长度是一个固定的值，一旦确定就不能更改。如果想添加或删除元素，需要创建一个新的数组。

排序算法

  排序算法是计算机科学中的一个经典问题，它涉及到将一组数据按照特定的顺序重新排列。Java提供了多种排序算法，每种算法都有其特点和适用场景。排序算法是对一组数据按照升序或降序排列的算法。在 Java 中，常用的排序算法有冒泡排序、选择排序和快速排序。

冒泡排序

  冒泡排序是一种简单直观的排序方法，通过重复遍历待排序的数组，比较每对相邻元素的大小，并在必要时交换它们的位置。冒泡排序是一种简单的排序算法。它的基本思想是将相邻的元素比较，如果前一个比后一个大，则交换它们的位置，直到完成整个数组的排序。

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

选择排序

  选择排序通过在未排序的序列中找到最小（或最大）的元素，将其放到已排序序列的末尾，然后再从剩余未排序元素中继续寻找最小（或最大）元素，以此类推。选择排序是一种简单的排序算法。它的基本思想是从数组中选择最小的元素，然后将其与数组的第一个元素交换，接着在剩下的元素中选择最小的元素，然后将其与数组的第二个元素交换，以此类推，直到完成整个数组的排序。

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

快速排序

  快速排序是一种分而治之的排序算法，通过选取一个“基准”元素，将数组分为两部分，一部分包含所有小于基准的元素，另一部分包含所有大于基准的元素。然后递归地对这两部分进行快速排序。快速排序是一种常用的排序算法。它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后分别对这两部分记录继续进行快速排序，以达到整个序列有序的目的。

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, right);
    }
}

public static int partition(int[] arr, int left, int right) {
    int pivot = arr[left];
    int i = left + 1;
    int j = right;
    while (i <= j) {
        while (i <= j && arr[i] <= pivot) {
            i++;
        }
        while (i <= j && arr[j] > pivot) {
            j--;
        }
        if (i < j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[left];
    arr[left] = arr[j];
    arr[j] = temp;
    return j;
}

测试用例

测试代码

  测试用例是验证排序算法正确性的关键。通过使用一组预定义的输入数组，我们可以检查排序算法是否能够正确地对其进行排序，并输出预期的排序结果。

  下面是测试排序算法的代码：

int[] arr = {5, 3, 6, 2, 7, 1, 9, 8, 4};
System.out.println("排序前：" + Arrays.toString(arr));
bubbleSort(arr);
System.out.println("冒泡排序后：" + Arrays.toString(arr));
selectionSort(arr);
System.out.println("选择排序后：" + Arrays.toString(arr));
quickSort(arr, 0, arr.length - 1);
System.out.println("快速排序后：" + Arrays.toString(arr));

代码解析

  如上段Java代码我演示了三种不同的排序算法：冒泡排序、选择排序和快速排序。代码首先定义了一个整型数组arr，并初始化为一个包含9个元素的数组。然后，代码依次执行了三种排序算法，并在每次排序后打印出数组的状态。

1. 冒泡排序 (bubbleSort)：

   • 冒泡排序是一种简单的排序算法，通过重复遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
   • 在代码中，冒泡排序后数组将被排序，然后打印排序后的数组。

2. 选择排序 (selectionSort)：

   • 选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
   • 代码中的选择排序将对数组进行排序，然后打印排序后的数组。

3. 快速排序 (quickSort)：

   • 快速排序是一种分而治之的排序算法，通过选取一个“基准”元素，然后将数组分为两部分，一部分包含所有小于基准的元素，另一部分包含所有大于基准的元素。然后递归地在这两个子数组上重复这个过程。
   • 代码中的快速排序接受三个参数：数组、起始索引和结束索引。它将对数组进行排序，然后打印排序后的数组。

  代码中还使用了System.out.println来打印排序前后的数组状态，使用Arrays.toString方法来将数组转换为易于阅读的字符串形式。

  注意，这段代码中也存在一个问题：就是在执行冒泡排序和选择排序后，数组已经被排序，但是快速排序之前并没有重新打乱数组，因此快速排序将对已经排序的数组进行操作，这可能不是预期的行为。通常，我们会在每种排序算法之前重新初始化数组，以确保每种排序算法都是从相同的未排序状态开始的。

全文小结

  本文详细介绍了数组长度的概念和几种常用的排序算法。通过实际的代码示例，我们展示了如何在Java中实现这些算法，并讨论了它们的效率和适用性。理解这些基础知识对于提高编程技能和优化程序性能至关重要。本篇文章介绍了数组长度和排序算法的基本概念。数组长度是数组中元素的个数，可用 length 属性获取。排序算法可用于将数组按升序或降序排列，常用的排序算法有冒泡排序、选择排序和快速排序。排序算法的效率取决于数据规模和算法实现。

附录源码

  如上涉及所有源码均已上传同步在Gitee，提供给同学们一对一参考学习，辅助你更迅速的掌握。

总结

  通过本篇文章的学习，读者应该对数组长度的管理以及如何实现和选择排序算法有了更深入的理解。在实际编程中，我们可以根据具体需求和数据规模，灵活选择最合适的排序方法，以提高程序的效率和性能。希望读者能够将这些知识应用到实际编程中，不断提升自己的编程能力。

☀️建议/推荐你

---

  无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学Java」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门Java编程，就像滚雪球一样，越滚越大，指数级提升。

📣关于我

---

我是bug菌，CSDN | 掘金 | infoQ | 51CTO 等社区博客专家，历届博客之星Top30，掘金年度人气作者Top40，51CTO年度博主Top12，华为云 | 阿里云| 腾讯云等社区优质创作者，全网粉丝合计15w+ ；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板等海量资料。