冒泡排序算法详解：时间复杂度、空间复杂度及优化

冒泡排序是一种简单的排序算法，其时间复杂度为 O(n^2)，空间复杂度为 O(1)。

冒泡排序算法原理：

冒泡排序算法通过比较相邻元素，将较大的元素向后移动，就像气泡在水中向上浮起一样。算法重复执行以下步骤，直到数组有序：

1. 从数组的第一个元素开始，依次比较相邻的两个元素。
2. 如果前一个元素大于后一个元素，则交换两个元素的位置。
3. 重复步骤 1 和 2，直到数组的最后一个元素。

代码示例：

public class InventorySort {

    public static void main(String[] args) {
        int[] inventory = {5, 8, 2, 10, 3};
        inventorySort(inventory);
        for (int i = 0; i < inventory.length; i++) {
            System.out.print(inventory[i] + ' ');
        }
    }

    // 库存排序方法
    public static void inventorySort(int[] inventory) {
        for (int i = 1; i < inventory.length; i++) {
            for (int j = 0; j < inventory.length - i; j++) {
                if (inventory[j] < inventory[j + 1]) {
                    int temp = inventory[j];
                    inventory[j] = inventory[j + 1];
                    inventory[j + 1] = temp;
                }
            }
        }
    }
}

冒泡排序的优化：

冒泡排序可以进行优化，例如加入一个标志位，当某一轮遍历中没有发生交换操作时，说明数组已经有序，可以提前结束排序。

优化后的代码：

public class InventorySort {

    public static void main(String[] args) {
        int[] inventory = {5, 8, 2, 10, 3};
        inventorySort(inventory);
        for (int i = 0; i < inventory.length; i++) {
            System.out.print(inventory[i] + ' ');
        }
    }

    // 库存排序方法
    public static void inventorySort(int[] inventory) {
        boolean swapped;
        for (int i = 1; i < inventory.length; i++) {
            swapped = false;
            for (int j = 0; j < inventory.length - i; j++) {
                if (inventory[j] < inventory[j + 1]) {
                    int temp = inventory[j];
                    inventory[j] = inventory[j + 1];
                    inventory[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;
            }
        }
    }
}

优化后的时间复杂度：

在最好的情况下，当数组已经有序时，冒泡排序的时间复杂度可以优化为 O(n)。

总结：

冒泡排序是一种简单易懂的排序算法，但其时间复杂度较高。在实际应用中，对于规模较小的数组，冒泡排序可以作为一种简单的排序方法。对于规模较大的数组，建议使用其他更高效的排序算法，例如快速排序或归并排序。