排序算法——冒泡排序

冒泡排序

冒泡排序是一种基础的交换排序。

之所以称为冒泡是因为冒泡排序的每一个元素都可以像气泡一样，通过设定的从小到大或者从大到小的排序顺序，一点点的朝着数组的一侧进行移动，达到最后的排序效果。

思想（从小到大顺序）

冒泡排序是把相邻的元素进行两两的比较，当一个元素 大于它的右侧相邻的元素的时候，这两个元素的位置进行交换，否者，这两个元素的位置不再变化。
如果是从大到小的顺序，只需要将大于的条件改为小于即可。

冒泡排序是一种稳定排序，也就是说，对于数组中存在有相等的数据元素，排序前后的顺序是不会改变的，这就是稳定排序的意思。

冒泡排序代码实现

排序算法有很多，但是初步接触的简单的就是冒泡和选择排序，可以通过冒泡排序进行排序算法的启蒙。

1. 冒泡实现的步骤
   
   代码的实现也很容易：我们只需要两个循环即可，外层循环需要控制需要循环的次数，内层循序处理每一回的冒泡逻辑处理，也就是先比较两者大小，符合定义的条件进行位置交换，否则不交换。

   public static void sort(int array[]){
   	//外层循环  控制需要排序的轮数
      for (int i = 0; i < array.length - 1; i++) {
      		//内层循环  控制每一回排序的处理
           for (int j = 0; j < array.length - 1 - i; j++) {
               int temp = 0;
               //此处是按照从小到大进行的排序
               if (array[j] > array[j+1]){
                   temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
               }
           }
       }
   }
   

   这里需要注意的就是排序的轮数不是数组的数据长度，而是数据长度减 1，原因很简单，对于一个含有n个数据的数组来说，进行了n-1回排序操作了之后，我们也就只剩下一个元素了，那这个元素肯定已经是排序好了的，不需要自己排序了啊。所以对于n个数据的数组，只需要进行n-1轮排序即可。

2. 优化：再看看贴图所给出的数组的排序，不难发现，其实我们在第二轮就已经排序好了，但是对于代码的实现还是需要进行第三轮，第四轮的排序，只有把外层循环执行完，代码才跳出循环，计算机可不如人们聪明，可以自己跳出循环。
   这个时候我们可以想想办法，对这个排序算法进行优化，对于排序的实际操作其实就是在内层循环的if语句内部，而且这里发生的操作是进行互换，如果此时没有进行互换会发生什么呢？也就是说没有数据交换，证明这里的数据应该是有序的。
   但是问题又出来了，这一次没有交换，也许是 3 6 4的排列呢？3和6确实不需要交换，但是6和4却是要交换的啊! 那么，继续深入，如果保存最后一次交换的下标值为边界，岂不是可以解决了。
   
   代码实现：

   public static void sort(int[] array){
     //记录最后一次交换的位置
       int lastIndex = 0;
       //最后一次交换元素的边界下标，每次比较只需要比较到这里为止，初始为数组下标最大值
       int border = array.length - 1;
       for (int i = 0; i < array.length - 1; i++) {
           for (int j = 0; j < border; j++) {
               int temp = 0;
               if (array[j] > array[j+1]){
                   temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
                   //更新为最后一次交换元素的位置
                   lastIndex = j;
               }
           }
           //将边界下标设置为最后一次交换元素时的位置，进行下一轮排序
           border = lastIndex;
       }
   }
   

3. 优化：不难想象，如果数组后面部分会出现已经排序好的情况，那么数组前面的部分很可能也会出现已经排序好的情况。
   例如：对于数组 [1,2,3,7,4,5,6]来说，前面部分1，2，3是已经排序后的，后面部分4，5，6也是已经排序好的，其实对于这个数组来说，我们只需要将7移动到数组的最后就已经排序成功了。
   通过上一步的优化，我们已经完成了后面部分的处理，但是前面部分的处理还需要想办法…
   可以知道，如果数组已经是有序的了，那么对于内层循环中的if语句块将不再是执行的，在数组有序了之后的下一轮排序之中，if语句块中的代码将不再执行，那么这个时候我们可以设置一个标记，如果一次if语句块中的语句都没执行，这个标记就可以作为判断的条件判断是否可以终止循环，执行完毕。
   代码实现：

   public static void sort(int[] array){
       //记录最后一次交换的位置
       int lastIndex = 0;
       //最后一次交换元素的边界下标，每次比较只需要比较到这里为止，初始为数组下标最大值
       int border = array.length - 1;
       for (int i = 0; i < array.length - 1; i++) {
           //标记，每一轮开始都为true
           boolean flag = true;
           for (int j = 0; j < border; j++) {
               int temp = 0;
               if (array[j] > array[j+1]){
                   temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
                   //如果有元素进行交换，则表示当前的数组还不是有序的数组，标记置为false
                   flag = false;
                   //更新为最后一次交换元素的位置
                   lastIndex = j;
               }
           }
           //将边界下标设置为最后一次交换元素时的位置，进行下一轮排序
           border = lastIndex;
           //如果标记依旧为true，说明数组已经是有序的了，直接跳出外层循序结束排序操作即可。
           if (flag){
               break;
           }
       }
   }