数据结构算法之冒泡排序

Posted 2021-02-13 guopengxia0719

今天来谈下冒泡排序算法，这次实现由两种形式如下所示：

1.对于长度为N的数据序列，没有加标签限制，针对一开始就是有序的数据序列，仍然需要排序N-1趟来完成排序。

2.对于长度为N的数据序列，加标了签限制，针对一开始就是有序的数据序列，仍然需要排序1趟就可以完成排序。

 

冒泡排序的过程可以简述如下：

  * 冒泡排序：
  *  相邻的2个数据进行排序对比，每次排序完一遍后，把最大的一个放到最后，
  *  每次排序完一趟后，会选出最大的一个放到最后，最后一个不需要对比，直接放到第一位即可。
  *  故，对n个数据进行冒泡排序，对比排序n-1趟即可完成。

 

实例说明如下所示：

列举数组实例：a[] = {23,34,56,78,65,90,88,92,18,21};

第 1 次排序： 23   34   56   65   78   88   90   18   21   【92】

第 2 次排序 ：23   34   56   65   78   88   18   21  【 90   92】

第 3 次排序： 23   34   56   65   78   18   21   【88   90   92】

第 4 次排序： 23   34   56   65   18   21   【78   88   90   92】

第 5 次排序： 23   34   56   18   21   【65   78   88   90   92】

第 6 次排序： 23   34   18   21   【56   65   78   88   90   92】

第 7 次排序： 23   18   21   【34   56   65   78   88   90   92】

第 8 次排序： 18   21  【 23   34   56   65   78   88   90   92】

第 9 次排序： 18  【 21   23   34   56   65   78   88   90   92】

最后一个数据18不需要进行比较，直接放到第一位即可。

至此，完成的冒泡排序的每趟排序细节如上所示。

算法的实现都是以java实现的，核心的算法是：

for(i=1;i<a.length;i++) {  //此处循环定义的是循环n-1趟，从第二个数据开始
   System.out.println();
    for(j=0;j<a.length-i;j++) { //此处循环是根据趟数减少的，每比较1此，确定一个数据，后面就会少比较一个数
    if(a[j]>a[j+1]) {
     temp=a[j+1];
     a[j+1]=a[j];
     a[j]=temp;
    }
   }
  }

为了结果实现更加清晰明了，会在程序中增加输出等语句，完整的java实现代码如下所示：‘

package com.three.thirdteen;

public class BubbleSortTest {
    
    public void SortTt(int a[]) {
        int i,j;
        int temp; //定义的用于交换数据的临时变量
         for(i=1;i<a.length;i++) {  //此处循环定义的是循环n-1趟，从第二个数据开始
            System.out.println();
             System.out.print("第 "+i+" 次排序结果：");
             for(j=0;j<a.length-i;j++) { //此处循环是根据趟数减少的，每比较1此，确定一个数据，后面就会少比较一个数
                if(a[j]>a[j+1]) {
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
             show(a);
        }
         System.out.println();
    }
    
    public void show(int a[]) {
       for(int i=0;i<a.length;i++) {
           System.out.print("   "+a[i]);
       }    
       System.out.println();
    }
    
    public static void main(String[] args) {
        
        int a[] = {23,34,56,78,65,90,88,92,18,21};
        BubbleSortTest bt=new BubbleSortTest();
        System.out.println("冒泡排序前的原始序列是：");
        bt.show(a);
         System.out.println("--------------排序开始---------------");
        bt.SortTt(a);
        System.out.println("--------------排序结束---------------");
         System.out.println("排序结果是：");
        bt.show(a);
    }
}

上述程序的运行结果为：

-----------------------------------------------------

有标签的冒泡排序：

以上是针对没有添加标签的，若一开始就是有序的数据序列，添加标签后，就可以一趟结束后，得出排序好的结果，

主要是针对一开始就是有序或者少量无需的数据序列，可以减少排序的趟数。

对上面的程序稍作修改，修改后的程序代码如下所示（程序的运行结果不变，仅在原有的程序中添加一个change标签）：

package com.three.thirdteen;

public class BubbleSortTest2 {

    /**
     * 冒泡排序：
     *  相邻的2个数据进行排序对比，每次排序完一遍后，把最大的一个放到最后，
     *  每次排序完一趟后，会选出最大的一个放到最后，最后一个不需要对比，直接放到第一位即可。
     *  故，对n个数据进行冒泡排序，对比排序n-1趟即可完成。
     *  
     *  此程序的实现增加了标签功能，主要是针对一开始就是有序或者少量无需的数据序列，
     *  可以减少排序的趟数。
     */
    
    public void SortTt(int a[]) {
        int i,j;
        int temp; //定义的用于交换数据的临时变量
        boolean change=false;
         for(i=1;i<a.length;i++) {  //此处循环定义的是循环n-1趟，从第二个数据开始
            System.out.println();
            change=false;
             System.out.print("第 "+i+" 次排序结果：");
             for(j=0;j<a.length-i;j++) { //此处循环是根据趟数减少的，每比较1此，确定一个数据，后面就会少比较一个数
                if(a[j]>a[j+1]) {
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                    change=true;
                }
            }
             if(!change) break;
             show(a);
        }
         System.out.println();
    }
    
    public void show(int a[]) {
       for(int i=0;i<a.length;i++) {
           System.out.print("   "+a[i]);
       }    
       System.out.println();
    }
    
    public static void main(String[] args) {
        
        int a[] = {23,34,56,78,65,90,88,92,18,21};
        BubbleSortTest2 bt=new BubbleSortTest2();
        System.out.println("冒泡排序前的原始序列是：");
        bt.show(a);
         System.out.println("--------------排序开始---------------");
        bt.SortTt(a);
        System.out.println("--------------排序结束---------------");
         System.out.println("排序结果是：");
        bt.show(a);
    }
}