排序算法_冒泡排序

一、原理

​ 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
​ 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

二、冒泡排序Java代码

1. 核心代码

   for (int i = 0; i < arr.length-1; i++) {
               for (int j = 0; j < arr.length-i-1; j++) {
                   if (arr[j]>arr[j+1]){
                       int temp = arr[j];
                       arr[j] = arr[j+1];
                       arr[j+1] = temp;
                   }
   

2. 完整代码

   //冒泡排序
   public class ArrayDemo2 {
       public static void main(String[] args) {
           //为了演示，设计为冒泡排序的最坏结果
           int[] arr = {5,4,3,2,1};
           int count = 0;  //计算排序次数
   
           //输出为排序前的内容
           System.out.println("未排序前的数组是：");
           for (int x = 0; x < arr.length; x++) {
               System.out.print(arr[x]+"\t");
           }
           //输出完后换行
           System.out.println();
   
           //冒泡排序（核心代码）
           for (int i = 0; i < arr.length-1; i++) {
               for (int k = 0; k < arr.length-1-i; k++) {
                   if (arr[k]>arr[k+1]){
                       int temp = arr[k];
                       arr[k] = arr[k+1];
                       arr[k+1] = temp;
                   }
   
                   //打印每次排序后的结果
                   count++;
                   System.out.println("第"+count+"次排序后的数组顺序为：");
                   for (int j = 0; j < arr.length; j++) {
                       System.out.print(arr[j]+"\t");
                   }
                   System.out.println();
               }
           }
       }
   }
   
   

   执行结果：

   

三、时间复杂度

1. 最优：

   若文件的初始状态是正序的，一趟扫描即可完成排序。其所需时间和需要排序的元素个数有关，
   所以，冒泡排序最好的时间复杂度为 O（n）。

2. 最坏：

   两个for循环都要完整的执行，即n*n

   在这种情况下，比较和移动次数均达到最大值, 其最坏时间复杂度为 ：O(n^2)

3. 综上，因此冒泡排序总的平均时间复杂度为 ：O(n^2)

四、算法稳定性

​ 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；

​ 如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。