冒泡排序_基于冒泡排序算法的机器人编程实现及其工业应用-CSDN博客

本文链接：https://blog.csdn.net/u012806787/article/details/82177684

简介

人生接触的第一个编程排序算法应该是：冒泡排序。

大学时通过模拟代码懵懵懂懂，十年之后才有时间去剖析这个算法的本质。

分析

冒泡排序：重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。

这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端-故得名“冒泡”。

冒泡排序算法（升序）的运作如下：

比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
由于它的简洁，冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。

视觉图效果

冒泡排序（升序）效果图

代码实现

    public int[] doItAsc(int[] nums) {
        if (null == nums || nums.length == 0 || nums.length == 1) {
            System.out.println("0   0");
            return nums;
        }

        int count = 0, swapCount = 0;
        // 外层循环仅仅决定比较次数
        for (int i = 0; i < nums.length - 1; i++) {
            // 内存循环决定比较项
            for (int j = 0; j < nums.length - 1 - i; j++) {
                count++;
                if (nums[j] > nums[j + 1]) {
                    swapCount++;
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                    swapCount ++;
                }
            }
        }
        System.out.println(count + "    " + swapCount);
        return nums;
    }

测试

测试用例

数组长度1
数组长度10
数组长度100
数组长度1000
数组长度10000
数组长度100000
数组长度1000000

期望：数组长度越大，耗时越长，且呈现几何倍数递增

测试条件

硬件环境

配置项	配置值
computer	MacBook Pro (Retina, 13-inch, Early 2015)
graphics	Intel Iris Graphics 6100 1536 MB
member	16 GB 1867 MHz DDR3
processor	3.1 GHz Dual-Core Intel Core i7

测试代码

public class AppTest{
   App app = new App();
   int[] one = new int[1];
   int[] two = new int[10];
   int[] three = new int[100];
   int[] four = new int[1000];
   int[] five = new int[10000];
   int[] six = new int[100000];

   @Before
   public void before(){
      one = generateRandomNumber(1);
      two = generateRandomNumber(10);
      three = generateRandomNumber(100);
      four = generateRandomNumber(1000);
      five = generateRandomNumber(10000);
      six = generateRandomNumber(100000);
   }
   @Test
   public void testDoItOne(){
      System.out.print(1 + "  ");
      app.doItAsc(one);
      System.out.println("----------------");
   }    

   @Test
   public void testDoItTwo(){
      System.out.print(2 + "  ");
      app.doItAsc(two);
      System.out.println("----------------");
   }
   @Test
   public void testDoItThree(){
      System.out.print(3 + "  ");
      app.doItAsc(three);
      System.out.println("----------------");
   }
   @Test
   public void testDoItFour(){
      System.out.print(4 + "  ");
      app.doItAsc(four);
      System.out.println("----------------");
   }
   @Test
   public void testDoItFive(){
      System.out.print(5 + "  ");
      app.doItAsc(five);
      System.out.println("----------------");
   }
   @Test
   public void testDoItSix(){
      System.out.print(6 + "  ");
      app.doItAsc(six);
      System.out.println("----------------");
   } 

   @Test
   public void testDoItSeven(){
      System.out.print(7 + "  ");
      int[] seven = generateRandomNumber(1000000);
      long start = System.currentTimeMillis();
      app.doItAsc(seven);
      long end = System.currentTimeMillis();
      System.out.println("----------------");
      System.out.println("耗时："+ (end - start));
   }

   public static int[] generateRandomNumber(int length){
      int[] randomArray = new int[length];
      Random random = new Random();
      for(int i=0;i<length;i++){
          randomArray[i] = random.nextInt(length);
      }
      return randomArray;
  }
}

测试结果

在这里插入图片描述

总结

T(1) = 长度1的数组排序耗时
毫秒级：T(1), T(10), T(100), T(1000) 20毫秒
秒级：T(10000) 150毫秒
十秒级:T(100000) 15秒
千秒级:T(1000000) 1400秒

从上到下递增倍数是：7倍， 10倍， 100倍

分水岭是数组长度10000.
在这里插入图片描述
整个排序期间，并未创建多余的数组占用内存（除了几个用户辅助判断查找次数，交换次数的变量）
时间复杂度：介于O(n)~O(n*n)之间
空间复杂度：O(1)

稳定排序

有一点我们很容易忽略的是排序算法的稳定性。

排序算法稳定性的简单形式化定义为：如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。

对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；而对于稳定的排序算法，必须对算法进行分析从而得到稳定的特性。需要注意的是，排序算法是否为稳定的是由具体算法决定的，不稳定的算法在某种条件下可以变为稳定的算法，而稳定的算法在某种条件下也可以变为不稳定的算法。

例如，对于冒泡排序，原本是稳定的排序算法，如果将记录交换的条件改成A[i] >= A[i + 1]，则两个相等的记录就会交换位置，从而变成不稳定的排序算法。

其次，说一下排序算法稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，前一个键排序的结果可以为后一个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位排序后元素的顺序在高位也相同时是不会改变的。

优化

    public int[] doItAsc(int[] nums) {
        if (null == nums || nums.length == 0 || nums.length == 1) {
            System.out.println("0   0");
            return nums;
        }

        int count = 0, swapCount = 0;
        // 外层循环仅仅决定比较次数
        for (int i = 0; i < nums.length - 1; i++) {
            // 内存循环决定比较项
            int flag = 0;
            for (int j = 0; j < nums.length - 1 - i; j++) {
                count++;
                if (nums[j] > nums[j + 1]) {
                    swapCount++;
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                    swapCount ++;
                    flag = 1;
                }
            }
            // 当无可用的比较时可跳出循环
            if(flag == 0){
                break;
            }
        }
        System.out.println(count + "    " + swapCount);
        return nums;
    }