public void sortByPriceUsingBubbleSort() { for (int i = 0; i < size - 1; i++) { boolean swapped = false; for (int j = 0; j < size - i - 1; j++) { if (drugs[j].getPrice() > drugs[j + 1].getPrice()) {

这段代码是使用冒泡排序算法对一个药品数组按照药品价格进行排序。冒泡排序算法的基本思想是将相邻的元素两两比较，如果前一个元素大于后一个元素，则交换这两个元素，一轮下来可以使得未排序部分的最大元素移动到最后。重复进行这个过程，直到所有元素都排好序。

在这段代码中，外层循环控制排序的轮数，内层循环用于在未排序的数据中进行相邻元素的比较。如果当前元素的价格比下一个元素的价格大，则交换这两个元素的位置。在每一轮内层循环结束后，如果没有进行任何元素交换，则说明数组已经排好序，可以提前结束循环。最终，当外层循环结束时，数组中的数据就被排好序了。

相关问题

有一个数组 int[] arr ={2,1,5,4,3}; 使用冒泡排序让数组内的元素按照从大到小排列java

你可以使用Java的冒泡排序算法对给定的整数数组 `arr` 进行降序排序。以下是相应的代码示例：

public class BubbleSortDescending {
    public static void main(String[] args) {
        int[] arr = {2, 1, 5, 4, 3};
        
        // 冒泡排序算法
        bubbleSort(arr, arr.length);

        // 输出排序后的数组
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    // 冒泡排序函数，传入数组和数组长度
    public static void bubbleSort(int[] array, int n) {
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;  // 标记是否发生过交换
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] < array[j + 1]) {
                    // 如果前一个元素小于后一个，交换它们
                    swap(array, j, j + 1);
                    swapped = true;
                }
            }
            // 如果一轮遍历中没有发生交换，说明已有序，提前终止
            if (!swapped) {
                break;
            }
        }
    }

    // 辅助函数，用于交换数组中的两个元素
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

运行这段代码后，`arr` 数组会变为 `[5, 4, 3, 2, 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`实例，并对给定的数组进行降序排序，然后打印出结果。