冒泡排序优化

最新推荐文章于 2025-04-15 11:56:20 发布

最新推荐文章于 2025-04-15 11:56:20 发布 · 678 阅读

文章标签：

#排序算法 #冒泡排序 #排序优化 #冒泡排序优化

算法专栏收录该内容

1 篇文章

订阅专栏

本文介绍了两种冒泡排序的优化方法。第一种通过设置标记，如果在一次外层循环中没有发生元素交换，则提前结束排序。第二种优化是每次循环进行两次冒泡，分别从前向后和从后向前，外层循环次数减半。通过这种方式，减少了冒泡排序的比较次数，提高了效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package bubbleSort;

/**

两种冒泡优化算法(思路):

1.每次循序出的最大/最小数不需要再次比较(减少内层循环); 考虑循环未跑完,已排好序(减少外层循环): 定义一个标记,每次外层循环时,标记跳出;若中途有替换则将标记置为false,不会跳出循环.(注:改标记要定义在循环内部,以便于每次循环后改标记会重置;)

2.在第一个排序的基础上改进算法. 构想:一次循环进行两次冒泡(前序进行冒大泡,倒序进行冒小泡),外层循环减半.//定义两个标记,左边每次循环标记右移,右边每次循环标记左移.当left>=right时结束,或内层两次循环未进行替换程序结束.

import java.util.Arrays;

public class BubbleSort {
   public static void main(String[] args) {
       int[] arr = new int[]{1,2,3,4};
       int[] arr2 = new int[]{5,4,3,2,1,10,9,8,7,6};
       int[] arr3 ={4,11,6,19,2,28,5,1,23,13,8,9};
       int[] arr4 ={4,11,7,6,19,24,3,99,2,28,5,1,23,34,25,13,8,9};
       int[] arr5 = new int[1000];
       for (int i = 0; i < arr5.length; i++) {
           arr5[i] = (int) (Math.random()*1000) ;
       }
       BubbleSort sort = new BubbleSort();
//       sort.sort1(arr5);//
       sort.sort2(arr5);//
    }
   /**
   * @author Administrator
   * @description 优化版冒泡排序(每次循序出的最大/最小数不需要再次比较(减少内层循环);考虑循环未跑完,已排好序(减少外层循环).)
   */
   void sort1(int[] arr){
       int count = 0;
       int tem;
       for (int i = 0; i < arr.length - 1; i++) {//趟数
           //定义一个标记,每次外层循环时,标记跳出;若中途有替换则将标记置为false,不会跳出循环.(注:改标记要定义在循环内部,以便于每次循环后改标记会重置;)
           boolean flag = true;
//           System.out.println("趟数:"+(i+1));
           for (int j = 0; j < arr.length-1-i; j++) {//次数
               if(arr[j]>arr[j+1]){ //大数替换前移,小数不动
                   tem = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = tem;
                   flag = false;
               }
//               System.out.println("次数:"+(j+1)+" "+Arrays.toString(arr));
               count++;
           }
           if(flag){
               break;
           }
       }
       System.out.println("sort1比较次数:"+count);
       System.out.println("sort1排序结果:" +Arrays.toString(arr));
   }
   /**
   * @author Administrator
   * @description 优化版冒泡排序(每次循序出的最大/最小数不需要再次比较(减少内层循环);考虑循环未跑完,已排好序(减少外层循环).)
   *                构想:一次循环进行两次冒泡(前序进行冒大泡,倒序进行冒小泡),外层循环减半.
   */
   void sort2(int[] arr){
       int count = 0;
       //定义两个标记,左边每次循环标记右移,右边每次循环标记左移.当left>=right时结束.
       int left=0;
       int right=arr.length-1;
       int tem;
       for (int i = 0; i < arr.length - 1; i++) {//趟数
           int flag = 0;
//           System.out.println("趟数:"+(i+1));
           for (int j = 0; j < arr.length-1-left-i; j++) {//前序(大数右移)
               if(arr[j]>arr[j+1]){ //大数替换前移,小数不动
                   tem = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = tem;
                   ++flag;
               }
//               System.out.println("次数:"+(j+1)+" "+Arrays.toString(arr));
               count++;
               right--;
           }

           for (int j = arr.length-1; j >i+right; j--) {//倒序(小数左移)
               if(arr[j-1]>arr[j]){ //大数替换前移,小数不动
                   tem = arr[j];
                   arr[j] = arr[j-1];
                   arr[j-1] = tem;
                   ++flag;
               }
//               System.out.println("次数:"+(j+1)+" "+Arrays.toString(arr));
               count++;
               left++;
           }
           if(flag==0/*||right>=left*/){
               break;
           }
       }
       System.out.println("sort2比较次数:"+count);
       System.out.println("sort2排序结果:" +Arrays.toString(arr));
   }
}