【详解】使用java解决-对10个数进行排序。

原创

大盘鸡拌面

发布于 2026-03-11 21:00:40

220

使用Java解决 - 对10个数进行排序

在编程中，排序算法是基础且重要的内容之一。本文将介绍如何使用Java语言对10个数进行排序。我们将使用几种不同的方法来实现这一功能，包括使用内置的排序方法和自定义排序算法。

1. 准备工作

首先，我们需要准备一个包含10个整数的数组。这些数字可以是随机生成的，也可以是手动指定的。这里我们手动指定这10个数字：

int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 8};

2. 使用Arrays.sort()方法排序

Java提供了一个非常方便的方法Arrays.sort()，可以直接对数组进行排序。这是最简单也是最快捷的方式。

代码示例

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 8};
        
        // 打印原始数组
        System.out.println("原始数组: " + Arrays.toString(numbers));
        
        // 使用Arrays.sort()方法排序
        Arrays.sort(numbers);
        
        // 打印排序后的数组
        System.out.println("排序后数组: " + Arrays.toString(numbers));
    }
}

输出结果

原始数组: [54, 26, 93, 17, 77, 31, 44, 55, 20, 8]
排序后数组: [8, 17, 20, 26, 31, 44, 54, 55, 77, 93]

3. 使用冒泡排序算法

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较每对相邻项，并交换它们的位置如果它们的顺序错误。这个过程会重复进行，直到没有更多的交换需要进行，这意味着列表已经排序完成。

代码示例

public class Main {
    public static void main(String[] args) {
        int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 8};
        
        // 打印原始数组
        System.out.println("原始数组: " + Arrays.toString(numbers));
        
        // 使用冒泡排序
        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = 0; j < numbers.length - 1 - i; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    // 交换位置
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }
        
        // 打印排序后的数组
        System.out.println("排序后数组: " + Arrays.toString(numbers));
    }
}

输出结果

原始数组: [54, 26, 93, 17, 77, 31, 44, 55, 20, 8]
排序后数组: [8, 17, 20, 26, 31, 44, 54, 55, 77, 93]

4. 使用快速排序算法

快速排序是一种高效的排序算法，采用分治法的策略。它的基本思想是选择一个“基准”元素，通过一趟排序将待排序的记录分割成独立的两部分，其中一部分的所有记录都比另一部分的所有记录小，然后分别对这两部分记录继续进行排序，以达到整个序列有序。

代码示例

public class Main {
    public static void main(String[] args) {
        int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 8};
        
        // 打印原始数组
        System.out.println("原始数组: " + Arrays.toString(numbers));
        
        // 使用快速排序
        quickSort(numbers, 0, numbers.length - 1);
        
        // 打印排序后的数组
        System.out.println("排序后数组: " + Arrays.toString(numbers));
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    public 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;
    }
}

输出结果

原始数组: [54, 26, 93, 17, 77, 31, 44, 55, 20, 8]
排序后数组: [8, 17, 20, 26, 31, 44, 54, 55, 77, 93]

下面是一个使用Java对10个数进行排序的示例代码。这个示例将使用Java内置的Arrays类中的sort方法来实现排序。

import java.util.Arrays;

public class SortExample {
    public static void main(String[] args) {
        // 定义一个包含10个整数的数组
        int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 87};

        // 打印排序前的数组
        System.out.println("排序前的数组:");
        System.out.println(Arrays.toString(numbers));

        // 使用Arrays类的sort方法对数组进行排序
        Arrays.sort(numbers);

        // 打印排序后的数组
        System.out.println("排序后的数组:");
        System.out.println(Arrays.toString(numbers));
    }
}

代码解释：

导入必要的包：import java.util.Arrays; 导入了Arrays类，该类提供了各种操作数组的方法。
定义主类和主方法：SortExample类中包含main方法，这是程序的入口点。
定义数组：int[] numbers 定义了一个包含10个整数的数组。
打印排序前的数组：使用System.out.println和Arrays.toString方法打印数组内容。
排序数组：调用Arrays.sort(numbers)方法对数组进行排序。
打印排序后的数组：再次使用System.out.println和Arrays.toString方法打印排序后的数组内容。

运行结果：

运行上述代码后，输出将会是：

排序前的数组:
[54, 26, 93, 17, 77, 31, 44, 55, 20, 87]
排序后的数组:
[17, 20, 26, 31, 44, 54, 55, 77, 87, 93]

其他排序方法：

如果你想要手动实现排序算法，比如冒泡排序、选择排序、插入排序等，也可以这样做。以下是一个简单的冒泡排序示例：

public class BubbleSortExample {
    public static void main(String[] args) {
        // 定义一个包含10个整数的数组
        int[] numbers = {54, 26, 93, 17, 77, 31, 44, 55, 20, 87};

        // 打印排序前的数组
        System.out.println("排序前的数组:");
        System.out.println(Arrays.toString(numbers));

        // 调用冒泡排序方法
        bubbleSort(numbers);

        // 打印排序后的数组
        System.out.println("排序后的数组:");
        System.out.println(Arrays.toString(numbers));
    }

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

在Java中，有多种方法可以对10个数进行排序。这里我将介绍几种常见的方法：使用数组和内置的排序方法、使用ArrayList和内置的排序方法，以及手动实现简单的排序算法（如冒泡排序）。

方法1：使用数组和内置的排序方法

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        // 定义一个包含10个数的数组
        int[] numbers = {5, 2, 8, 3, 9, 1, 6, 4, 7, 0};

        // 使用Arrays类的sort方法对数组进行排序
        Arrays.sort(numbers);

        // 输出排序后的数组
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

方法2：使用ArrayList和内置的排序方法

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListSortExample {
    public static void main(String[] args) {
        // 创建一个包含10个数的ArrayList
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(3);
        numbers.add(9);
        numbers.add(1);
        numbers.add(6);
        numbers.add(4);
        numbers.add(7);
        numbers.add(0);

        // 使用Collections类的sort方法对ArrayList进行排序
        Collections.sort(numbers);

        // 输出排序后的ArrayList
        System.out.println("Sorted list: " + numbers);
    }
}

方法3：手动实现冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置。

public class BubbleSortExample {
    public static void main(String[] args) {
        // 定义一个包含10个数的数组
        int[] numbers = {5, 2, 8, 3, 9, 1, 6, 4, 7, 0};

        // 手动实现冒泡排序
        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = 0; j < numbers.length - 1 - i; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    // 交换位置
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }

        // 输出排序后的数组
        System.out.println("Sorted array: " + Arrays.toString(numbers));
    }
}

总结

以上三种方法都可以有效地对10个数进行排序。使用内置的排序方法（如Arrays.sort()或Collections.sort()）通常是最简单和最高效的方式，因为这些方法已经经过优化。如果你想要学习排序算法的内部工作原理，手动实现一个简单的排序算法（如冒泡排序）是一个很好的练习。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java8

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java8

登录后参与评论

0 条评论

热度