Java冒泡排序详解

时间 2019-11-15

原文原文链接

Java冒泡排序

排序算法概述

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操做。排序算法，就是如何使得记录按照要求排列的方法。排序算法在不少领域获得至关地重视，尤为是在大量数据的处理方面。java

稳定性：一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在本来的列表中R出如今S以前，在排序过的列表中R也将会是在S以前。算法

若是算法是稳定的有什么好处呢？排序算法若是是稳定的，那么从一个键上排序，而后再从另外一个键上排序，第一个键排序的结果能够为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。数组

排序算法根据是否须要访问外存分为内部排序和外部排序。学习

内部排序是指待排序列彻底存放在内存中所进行的排序过程，适合不太大的元素序列。测试

外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件没法一次装入内存，须要在内存和外部存储器之间进行屡次数据交换，以达到排序整个文件的目的。this

咱们如今要讨论的排序都是内部排序。spa

冒泡排序指针

冒泡排序的效率很低，可是算法实现起来很简单，所以很适合做为研究排序的入门算法。code

基本思想cdn

对当前还未排好序的范围内的所有数，自上而下对相邻的俩个数依次进行比较和调整，让较大的数下沉，较小的数往上冒。即：每当俩相邻的数比较后发现他们的排序与排序的要求相反时，就将他们交换。每次遍历均可肯定一个最大值放到待排数组的末尾，下次遍历，对该最大值以及它以后的元素再也不排序（已经排好）。

java实现

public class Sort{  
   
  private int [] array;  
  public Sort(int [] array){  
     this.array = array;  
  }  
   
  //按顺序打印数组中的元素  
  public void display(){  
     for(int i=0;i<array.length;i++){  
         System.out.print(array[i]+"\t");  
     }  
     System.out.println();  
  }  
   
  //冒泡排序  
  public void bubbleSort(){  
     int temp;  
     int len = array.length;  
     for(int i=0;i<len-1;i++){  //外层循环：每循环一次就肯定了一个相对最大元素  
         for(int j=1;j<len-i;j++){  //内层循环：有i个元素已经排好，根据i肯定本次的比较次数  
            if(array[j-1]>array[j]){  //若是前一位大于后一位，交换位置  
                temp = array[j-1];  
                array[j-1] = array[j];  
                array[j] = temp;  
            }  
         }  
         System.out.print("第"+(i+1)+"轮排序结果：");  
         display();  
     }  
  }         
}  复制代码

测试：

public static void main(String[] args) {  
     int [] a = {1,5,4,11,2,20,18};  
     Sort sort = new Sort(a);  
     System.out.print("未排序时的结果：");  
     sort.display();  
     sort.bubbleSort();  
}  复制代码

打印结果：

算法分析

上面的例子中，待排数组中一共有7个数，第一轮排序时进行了6次比较，第二轮排序时进行了5比较，依次类推，最后一轮进行了一次比较。加入元素总数为N，则一共须要的比较次数为：

(N-1)+ (N-2)+ (N-3)+ ...1=N*(N-1)/2复制代码

这样，算法约作了N2/2次比较。由于只有在前面的元素比后面的元素大时才交换数据，因此交换的次数少于比较的次数。若是数据是随机的，大概有一半数据须要交换，则交换的次数为N2/4（不过在最坏状况下，即初始数据逆序时，每次比较都须要交换）。

交换和比较的操做次数都与N2成正比，因为在大O表示法中，常数忽略不计，冒泡排序的时间复杂度为O(N2)。O(N2)的时间复杂度是一个比较糟糕的结果，尤为在数据量很大的状况下。因此冒泡排序一般不会用于实际应用。

冒泡排序的改进

上面已经分析过，冒泡排序的效率比较低，因此咱们要经过各类方法改进。

最简单的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程当中是否有数据交换，若是进行某一趟排序时并无进行数据交换，则说明数据已经按要求排列好，可当即结束排序，避免没必要要的比较过程.

在上例中，第四轮排序以后实际上整个数组已是有序的了，最后两轮的比较不必进行。

改进后的代码以下：

//冒泡排序改进1  
  public void bubbleSort_improvement_1(){  
     int temp;  
     int len = array.length;  
      
     for(int i=0;i<len-1;i++){   
         boolean exchange = false;  //设置交换变量  
         for(int j=1;j<len-i;j++){   
            if(array[j-1]>array[j]){  //若是前一位大于后一位，交换位置  
                temp = array[j-1];  
                array[j-1] = array[j];  
                array[j] = temp;  
                 
                if(!exchange) exchange =true;  //发生了交换操做  
            }  
         }  
         System.out.print("第"+(i+1)+"轮排序结果：");  
         display();  
         if(!exchange) break;  //若是上一轮没有发生交换数据，证实已是有序的了，结束排序  
     }  
   }复制代码

用一样的初始数组测试，打印结果以下：

上面的改进方法，是根据上一轮排序有没有发生数据交换做为标识，进一步思考，若是上一轮排序中，只有后一段的几个元素没有发生数据交换，是否是能够断定这一段不用在进行比较了呢？答案是确定的。

例如上面的例子中，前四轮的排序结果为：

未排序时的结果：1   5  4  11 2  20 18
第1轮排序结果：1  4  5  2  11 18 20
第2轮排序结果：1  4  2  5  11 18 20
第3轮排序结果：1  2  4  5  11 18 20
第4轮排序结果：1  2  4  5  11 18 20复制代码

第1轮排序以后，十一、1八、20已是有序的了，后面的几回排序后它们的位置都没有变化，可是根据冒泡算法，18依然会在第2轮参与比较，11依然会在第2轮、第3轮参与比较，其实都是无用功。

咱们能够对算法进一步改进：设置一个pos指针，pos后面的数据在上一轮排序中没有发生交换，下一轮排序时，就对pos以后的数据再也不比较。

代码改动以下：

//冒泡排序改进2  
public void bubbleSort_improvement_2(){  
   int temp;  
   int counter = 1;  
   int endPoint = array.length-1;  //endPoint表明最后一个须要比较的元素下标  
    
   while(endPoint>0){   
      intpos = 1;  
      for(int j=1;j<=endPoint;j++){    
          if(array[j-1]>array[j]){  //若是前一位大于后一位，交换位置  
             temp= array[j-1];  
             array[j-1]= array[j];  
             array[j]= temp;  
                  
             pos= j;  //下标为j的元素与下标为j-1的元素发生了数据交换  
          }  
      }  
      //下一轮排序时只对下标小于pos的元素排序，下标大于等于pos的元素已经排好  
      endPoint= pos-1;  
       
      System.out.print("第"+counter+"轮排序结果：");  
      display();  
   }  
} 复制代码

对的算法来讲，没有最好，只有更好。上面的两种改进方法其实治标不治本，是一种“扬汤止沸”的改进，下面咱们来一次“釜底抽薪”的改进。

传统的冒泡算法每次排序只肯定了最大值，咱们能够在每次循环之中进行正反两次冒泡，分别找到最大值和最小值，如此可以使排序的轮数减小一半。

改进代码以下：

//冒泡排序改进3  
public void bubbleSort_improvement_3(){  
   int temp;  
   int low = 0;  
   int high = array.length-1;  
   int counter = 1;  
   while(low<high){   
       
      for(int i=low;i<high;++i){   //正向冒泡，肯定最大值  
          if(array[i]>array[i+1]){  //若是前一位大于后一位，交换位置  
             temp= array[i];  
             array[i]= array[i+1];  
             array[i+1]= temp;  
          }  
      }  
      --high;  
       
      for(int j=high;j>low;--j){   //反向冒泡，肯定最小值  
          if(array[j]<array[j-1]){  //若是前一位大于后一位，交换位置  
             temp= array[j];  
             array[j]= array[j-1];  
             array[j-1]= temp;  
          }  
      }  
      ++low;  
       
      System.out.print("第"+counter+"轮排序结果：");  
      display();  
      counter++;  
   }  
} 复制代码

若是有兴趣和咱们一块儿讨论问题的话，不妨加下咱们群吧，记得加群的时候写上我名字 ID：BigMoreKT：984370849

想要深刻学习的同窗们能够加入QQ群讨论，有全套资源分享，经验探讨，没错，咱们等着你，分享互相的故事!

Java冒泡排序详解