数据结构-冒泡排序Java实现

一、引言

    冒泡排序是一种基础的比较排序算法，它的思想很简单：重复地遍历待排序的元素列表，比较相邻元素，如果它们的顺序不正确，则交换它们。这个过程不断重复，直到整个数组都排序好。冒泡排序的时间复杂度为O(n^2)，因此不适用于大规模数据集，但对于小型数据集是一个很好的算法。

二、算法步骤

冒泡排序的基本步骤如下：
1.从数组的第一个元素开始，依次比较相邻的两个元素。
2.如果前一个元素大于后一个元素，交换它们。
3.继续向数组的下一对元素执行相同的操作，直到达到数组末尾。
4.重复步骤1-3，直到没有任何交换发生，这时数组已经排序完成。

三、原理演示

假设我们有以下整数数组：
[5, 3, 1, 4, 2]

• 第一轮：
  在第一轮中，算法将比较相邻的元素并进行交换，使较大的元素 “冒泡” 到数组的末尾。
  比较 5 和 3，交换它们，数组变为： [3, 5, 1, 4, 2]
  比较 5 和 1，交换它们，数组变为： [3, 1, 5, 4, 2]
  比较 5 和 4，交换它们，数组变为： [3, 1, 4, 5, 2]
  比较 5 和 2，交换它们，数组变为： [3, 1, 4, 2, 5]
  在第一轮结束时，最大的元素 5 已经被移动到数组的最后。
• 第二轮：
  在第二轮中，算法再次遍历数组，比较相邻元素并进行交换。
  比较 3 和 1，交换它们，数组变为： [1, 3, 4, 2, 5]
  比较 3 和 4，不交换。
  比较 4 和 2，交换它们，数组变为： [1, 3, 2, 4, 5]
  比较 4 和 5，不交换。
  在第二轮结束时，第二大的元素 4 已经被移动到数组的倒数第二位。
• 第三轮：
  继续相同的过程。
  比较 1 和 3，不交换。
  比较 3 和 2，交换它们，数组变为： [1, 2, 3, 4, 5]
  比较 3 和 4，不交换。
  在第三轮结束时，第三大的元素 3 已经被移动到数组的倒数第三位。
• 第四轮：
  比较 1 和 2，不交换。
  在第四轮结束时，第四大的元素 2 已经被移动到数组的倒数第四位。
• 第五轮：
  比较 1 和 2，不交换。
  在第五轮结束时，数组已经完全排序。

最终，冒泡排序算法完成了对整数数组的排序。
冒泡排序算法会在每一轮中将一个最大的元素 “冒泡” 到数组的末尾，这就是为什么它被称为冒泡排序。算法不断重复这个过程，直到没有需要交换的元素，这时数组已经排好序。冒泡排序虽然不是最高效的排序算法，但它对于理解排序算法的基本概念是非常有帮助的。

四、代码实战

以下是两种冒泡排序的实现代码，大家看看哪种更适合你，易于理解。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("原始数组：");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("排序后的数组：");
        printArray(arr);
    }

    // 冒泡排序实现
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;

        for (int i = 0; i < n - 1; i++) {
            swapped = false;

            for (int j = 0; j < n - i - 1; 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;
                    swapped = true;
                }
            }

            // 如果在一轮循环中没有发生交换，数组已经排序完成
            if (!swapped) {
                break;
            }
        }
    }

    // 辅助方法，用于打印数组
    public static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

上述代码演示了冒泡排序的实现。它首先定义了一个包含整数数组的示例，然后调用 bubbleSort 方法来对数组进行排序。bubbleSort 方法使用两个嵌套的循环来比较相邻元素并交换它们，直到整个数组都排好序。在每一轮循环结束后，检查是否发生了交换，如果没有交换发生，表示数组已经排序好，可以提前退出循环。

public class BubbleSort {  
    public static void main(String[] args) {  
        int[] array = {64, 34, 25, 12, 22, 11, 90};  
        System.out.println("Unsorted array: ");  
        printArray(array);  
        bubbleSort(array);  
        System.out.println("Sorted array: ");  
        printArray(array);  
    }  
  
    static void bubbleSort(int[] array) {  
        int n = array.length;  
        for (int i = 0; i < n-1; i++) {  
            for (int j = 0; j < n-i-1; j++) {  
                if (array[j] > array[j+1]) {  
                    // swap array[j+1] and array[j]  
                    int temp = array[j];  
                    array[j] = array[j+1];  
                    array[j+1] = temp;  
                }  
            }  
        }  
    }  
  
    static void printArray(int[] array) {  
        int n = array.length;  
        for (int i = 0; i < n; ++i) {  
            System.out.print(array[i] + " ");  
        }  
        System.out.println();  
    }  
}

在上述代码中，我们定义了一个bubbleSort方法来实现冒泡排序算法。该算法采用嵌套的for循环，外层循环用于遍历整个数组，内层循环用于比较相邻的元素并进行交换，直到整个数组都被排序完成。printArray方法用于打印未排序和已排序的数组。

五、结论

我们一起来总结一下冒泡排序：

1. 冒泡排序的基本思想是将相邻的元素进行比较和交换，将较大的元素逐渐“冒泡”到数列的末尾，从而实现升序或降序排列。
2. 冒泡排序的时间复杂度为O(n^2)，其中n表示要排序的元素个数。这是因为在最坏情况下，冒泡排序需要遍历数列两次，每次遍历都需要进行n-1次比较和交换操作。
3. 冒泡排序的空间复杂度为O(1)，因为它只需要使用一个额外的变量来交换相邻元素的位置。
4. 冒泡排序是一种稳定的排序算法，即相同元素的相对位置在排序后不会改变。
5. 冒泡排序对于小规模数据集来说表现尚可，但是对于较大规模数据集来说效率较低。因此，在实际应用中，通常会优先考虑使用其他更高效的排序算法，如快速排序、归并排序等。
6. 可以通过对冒泡排序进行优化，如使用标志变量来记录数列是否已经完成排序，从而减少不必要的比较和交换操作，提高算法效率。但是这并不会改变冒泡排序的时间复杂度。
   点赞收藏，富婆包养✋✋