含泪总结篇：数据结构—排序之冒泡排序

最新推荐文章于 2022-12-07 12:29:06 发布

我是昆虫

最新推荐文章于 2022-12-07 12:29:06 发布

阅读量672

点赞数 1

分类专栏： Java 文章标签：冒泡排序数据结构排序

本文链接：https://blog.csdn.net/XJ10160/article/details/101536514

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

数据结构—排序之冒泡排序

注：此文档《数据结构与算法之美》的课上学习和自习总结的。属于原创文章，如发现错误，请指出

系列文章
什么是数据结构？什么是算法？
数据结构—数组
 数据结构—链表
 数据结构—栈
 数据结构—队列
 数据结构—排序

数据结构—排序之冒泡排序

##冒泡排序

冒泡排序：冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让他两个互换，一次至少移动他元素应该在的位置，重复n此，就完成了那个排序工作
特点
优势：稳定，空间复杂度O（1），属于就地（原地）排序算法
劣势：慢，每次只能移动两个
看下图我们来了解下冒泡排序的过程
有序度是一组数据中具有有序元素的个数（比如上面的例子中 5 ）
满有序度：一组完全有序的数据（公式：n*(n-1)/2）
逆序度是冒泡排序是需要交换元素的次数（等于满有序度-有序度）

冒泡排序代码实现1

/**
 -  冒泡排序
 - 冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。
 - 如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n 次，
 - 就完成了 n 个数据的排序工作。
 **/
public class BubbleSort {
    public void bubbleSort(Integer[] arr, int n) {
        if (n <= 1) return;       //如果只有一个元素就不用排序了
 
        for (int i = 0; i < n; ++i) {
            // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {        //此处你可能会疑问的j<n-i-1，因为冒泡是把每轮循环中较大的数飘到后面，
                // 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少
                if (arr[j] > arr[j + 1]) {        //即这两个相邻的数是逆序的，交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;//没有数据交换，数组已经有序，退出排序
        }
    }
 
    public static void main(String[] args) {
        Integer arr[] = {2, 4, 7, 6, 8, 5, 9};
        SortUtil.show(arr);
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.bubbleSort(arr, arr.length);
        SortUtil.show(arr);
    }
}

可能大家对上面for (int j = 0; j < n - i - 1; ++j)的这句有点不理解，我帮助大家解释分析下

for (int j = 0; j < n - i - 1; ++j) 为什么需要 -1。
- 因为倒数第一个元素如果比倒数倒数第二个元素大，就已经执行了数据交换
for (int j = 0; j < n - i - 1; ++j) 为什么需要 -i,执行下面代码

  public static int[] bubbleSort(int[] a){
      if (a.length<=1)return a;
      for (int i = 0; i <a.length-1 ; i++) {
          if (a[i]>a[i+1]){
              int t=a[i];
              a[i]=a[i+1];
              a[i+1]=t;
          }
      }
      return a;
  }

大家多次执行上面代码之后就会发现，每次最大排序后，第一次最大的数在最后面，第二次第二大的数在倒数第二个位置，这次每次循环下来，是不是数据大的是不是默认排序到后面了，所以这里
-i

冒泡排序代码实现2

 public static int[] bubbleSort2(int[] arr) {
       System.out.println(arr.length);
       if (arr.length <= 1) return arr;//已经有序
       for (int i = 0; i < arr.length; i++) {
           for (int j = i + 1; j < arr.length; j++) {
               if (arr[i] > arr[j]) {
                   int a = arr[i];
                   arr[i] = arr[j];
                   arr[j] = a;
               }
           }
       }
       return arr;
   }

上面这个冒泡算法比较简单，也没有什么需要解释的，大家看下就行。

大家看看下面的这段代码：


public static int[] bubbleSort(int[] a) {
     
       if (a.length <= 1) return a;
       for (int i = 0; i < a.length-1; i++) {
           if (a[i] > a[i + 1]) {
               int t = a[i];
               a[i] = a[i + 1];
               a[i + 1] = t;
           }
       }
       return a;
   }

假如我们的a数组是这个值： int arr[] = new int[]{1, 25, 2, 35, 14, 58, 10};
我们执行完bubbleSort（arr）后是怎么样的结果呢？
这里我把答案告诉大家：arr={1,2,25,14,35,10,58}
我为什么要这么提示大家注意一下呢？