排序:冒泡排序

WOW爱算法

已于 2024-04-02 11:23:43 修改

阅读量417

点赞数 13

文章标签：算法数据结构排序算法 java

于 2024-03-31 22:35:23 首次发布

本文链接：https://blog.csdn.net/2301_80761442/article/details/137209008

版权

本文介绍了冒泡排序的原理、基本步骤，提供Java代码示例，并讨论了原始排序、代码优化1和优化2，以及其时间复杂度。尽管冒泡排序效率不高，但在特定情况下仍具优势。

摘要由CSDN通过智能技术生成

一.冒泡排序介绍:

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“冒”到数列的顶端。

二.冒泡排序的基本步骤：

比较相邻的元素。如果第一个比第二个大（升序排序），就交换它们两个；
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
针对所有的元素重复以上的步骤，除了最后已经排序好的元素；
重复步骤1~3，直到排序完成。

三.冒泡排序的java代码实现:

1.原始冒泡排序：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr={5,3,1,9,2,8,4,7,6};
        int n=arr.length;
        //k是用来交换两个元素
        int k;
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if (arr[j]>arr[j+1]){
                    // 交换 arr[j+1] 和 arr[j]
                    k=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=k;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
}

对于外层循环每次都将最大的元素冒到数列的顶端;

以上述代码为例,就是在第一轮循环中把9"冒"到该数列的顶端;

这是最原始的冒泡排序，该排序算法的每一轮要遍历所有元素，并且轮数和元素数量只少1;

时间复杂度：
最优时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)

这个算法的效率是非常低的。

2.冒泡排序代码优化1

与原始冒泡排序相似，但在每一轮遍历后，都会检查是否有交换发生。
如果在某一轮遍历中没有交换发生，这意味着数组已经排序完成，算法可以提前结束。
这种优化可以减少不必要的比较，当数组接近有序时，可以显著提高效率。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        int n = arr.length;
        boolean swapped;
        //k是用来交换两个元素
        int k;
        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+1] 和 arr[j]
                    k = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = k;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;
            }
        }
            for (int i : arr) {
                System.out.print(i + " ");
            }
        }
    }

利用布尔变量swapped作为标记。如果在本轮排序中，没有元素交换，说明数组已经有序，直接跳出大循环。经过这次优化后，如果数组已经有顺序了，可以减少比较的轮数。

3.冒泡排序代码优化2

该优化应用于本身就比较有序的情况

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        int len = arr.length - 1;
        boolean swapped;
        //k是用来交换两个元素
        int k;
        int lastPosition = 0; // 记录这一轮最后一次比较的较小那个值,下一轮就比较到这里
        for (int i = 0; i < arr.length; i++) {
            swapped = false;
            for (int j = 0; j < len; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j+1] 和 arr[j]
                    k = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = k;
                    swapped = true;
                    lastPosition = j;
                }
            }
            len=lastPosition;
            if (!swapped) {
                break;
            }
        }
            for (int i : arr) {
                System.out.print(i + " ");
            }
        }
    }