数据结构算法之冒泡排序

Posted guopengxia0719

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构算法之冒泡排序相关的知识,希望对你有一定的参考价值。

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

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);
    }
}

 

以上是关于数据结构算法之冒泡排序的主要内容,如果未能解决你的问题,请参考以下文章

python 数据结构与算法之排序(冒泡,选择,插入)

数据结构之--冒泡排序算法及改进

排序算法之冒泡和快排

排序算法之冒泡排序

数据结构与算法之排序算法:交换排序

数据结构之排序算法Java实现—— 冒泡排序算法