设计一个BubbleSort类，定义数组int[]={3，1，9，30，7，5，24，15，19}并用冒泡排序对数组元素从小到大排序}

好的，以下是BubbleSort类的实现：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 1, 9, 30, 7, 5, 24, 15, 19};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

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

输出结果为：[1, 3, 5, 7, 9, 15, 19, 24, 30]

相关问题

设计一个BubbleSort类。 （1）定义数组int[] arr = { 3, 1, 9, 30,7, 5,24,15,19 }; （2）用冒泡排序对数组元素从大到小排序。

以下是BubbleSort类的示例代码，其中包括了对数组元素从大到小排序的实现：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = { 3, 1, 9, 30, 7, 5, 24, 15, 19 };

        // 冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    // 交换相邻两个元素的位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 输出排序后的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果为：

30 24 19 15 9 7 5 3 1

6.设计一个BubbleSort类。 （1）定义数组int[] arr = { 3, 1, 9, 30,7, 5,24,15,19 }; （2）用冒泡排序对数组元素从大到小排序。

为了设计一个名为`BubbleSort`的类来对给定的整数数组进行降序排序，你可以按照以下步骤进行：

public class BubbleSort {
    private int[] arr;

    // 构造函数接收一个整数数组作为输入
    public BubbleSort(int[] inputArray) {
        this.arr = inputArray.clone(); // 拷贝原始数组，避免修改传入的参数
    }

    // 冒泡排序方法
    public void bubbleSortDescending() {
        boolean swapped;
        for (int i = 0; i < arr.length - 1; i++) {
            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;
                }
            }
            // 如果一轮循环未发生交换，说明已有序，提前结束
            if (!swapped) {
                break;
            }
        }
    }

    // 提供一个方法获取排序后的数组
    public int[] getSortedArray() {
        return Arrays.copyOf(arr, arr.length);
    }

    // 测试代码，用于初始化数组并排序
    public static void main(String[] args) {
        int[] arr = { 3, 1, 9, 30, 7, 5, 24, 15, 19 };
        BubbleSort sort = new BubbleSort(arr);
        sort.bubbleSortDescending();
        System.out.println("排序后的数组：");
        for (int num : sort.getSortedArray()) {
            System.out.print(num + " ");
        }
    }
}

在这个类中，我们首先创建了表示数组的私有变量`arr`，然后提供了一个构造函数接受一个整数数组。`bubbleSortDescending`方法实现了冒泡排序算法，并将数组按降序排列。最后，`getSortedArray`方法返回排序后的数组副本，防止直接修改原数组。

在测试`main`方法中，我们创建了一个`BubbleSort`实例，并对给定的数组进行降序排序，然后打印出结果。