排序系列 之 冒泡排序及其改进算法 —— Java实现

冒泡排序算法

冒泡排序算法 改进一

冒泡排序算法 改进二

冒泡排序算法 改进三

冒泡排序算法

　基本思想：

　　在要排序的一组数中，对当前还未排好序的范围内的全部数据，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的数往上冒。即依次比较相邻的两个数，若发现它们的排序与排序要求相反时，就将它们互。

　实例：

　　待排序数组 int a[] = {49,38,65,97,76,13,27,32};

　　共 N=8 个数据，需要 N-1=7 趟排序，第 i 趟排序共比较 N-i 次

　　每趟排序都会找出一个 待排序数据 中的较大值

　　第一趟排序：

　　　　第1次比较调整：49和38比较，49>38，交换位置：　　38 49 65 97 76 13 27 32

　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 97 76 13 27 32

　　　　第3次比较调整：65和97比较，65<97，不交换位置：　38 49 65 97 76 13 27 32

　　　　第4次比较调整：97和76比较，97>76，交换位置：　　38 49 65 76 97 13 27 32

　　　　第5次比较调整：97和13比较，97>13，交换位置：　　38 49 65 76 13 97 27 32

　　　　第6次比较调整：97和27比较，97>27，交换位置：　　38 49 65 76 13 27 97 32

　　　　第7次比较调整：97和32比较，97>32，交换位置：　　38 49 65 76 13 27 32

　　第二趟排序：

　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 65 76 13 27 32

　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 76 13 27 32

　　　　第3次比较调整：65和76比较，65<76，不交换位置：　38 49 65 76 13 27 32

　　　　第4次比较调整：76和13比较，76>13，交换位置：　　38 49 65 13 76 27 32

　　　　第5次比较调整：76和27比较，76>27，交换位置：　　38 49 65 13 27 76 32

　　　　第6次比较调整：76和32比较，76>32，交换位置：　　38 49 65 13 27 32 76 97

　　第三趟排序：

　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 65 13 27 32 76 97

　　　　第2次比较调整：49和65比较，49<65，不交换位置：　38 49 65 13 27 32 76 97

　　　　第3次比较调整：65和13比较，65>13，交换位置：　　38 49 13 65 27 32 76 97

　　　　第4次比较调整：65和27比较，65>27，交换位置：　　38 49 13 27 65 32 76 97

　　　　第5次比较调整：65和32比较，65>32，交换位置：　　38 49 13 27 32 65 76 97

　　第四趟排序：

　　　　第1次比较调整：38和49比较，38<49，不交换位置：　38 49 13 27 32 65 76 97

　　　　第2次比较调整：49和13比较，49>13，交换位置：　　38 13 49 27 32 65 76 97

　　　　第3次比较调整：49和27比较，49>76，不交换位置：　38 13 27 49 32 65 76 97

　　　　第4次比较调整：49和32比较，49>32，交换位置：　　38 13 27 32 49 65 76 97

　　第五趟排序：

　　　　第1次比较调整：38和13比较，38>13，交换位置：　　13 38 27 32 49 65 76 97

　　　　第2次比较调整：38和27比较，38>27，交换位置：　　13 27 38 32 49 65 76 97

　　　　第3次比较调整：38和32比较，38>32，交换位置：　　13 27 32 38 49 65 76 97

　　第六趟排序：

　　　　第1次比较调整：13和27比较，13<27，不交换位置：　13 27 32 38 49 65 76 97

　　　　第2次比较调整：27和32比较，27<32，不交换位置：　13 27 32 38 49 65 76 97

　　第七趟排序：

　　　　第1次比较调整：13和27比较，13<27，不交换位置：　13 27 32 38 49 65 76 97

　Java实现：

　　核心代码

private void bubbleSort(int a[]){
    int n=a.length;
    for(int i=0 ; i<n-1; i++) {
        for(int j=0; j<n-i-1; j++) {
            if(a[j] > a[j+1]){
                int temp = a[j] ; a[j] = a[j+1] ;  a[j+1] = temp;
            }
        }
    }
}

　　完整代码

package sort;
/**
 * 冒泡算法 及其 改进算法的实现
 * 稳定算法
 * @author 那一季的银杏叶
 *
 */
public class BubbleSort {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BubbleSort().run();
    }
    public void run(){
        int a[] = {49,38,65,97,76,13,27,32};
        /**
         * 冒泡排序
         */
        bubbleSort(a);
    }
    /**
     * 冒泡算法
     */
    private void bubbleSort(int a[]){
        System.out.println("———————————————————冒泡排序算法—————————————————————");
        int n=a.length;
        for(int i=0 ; i<n-1; i++) {
            for(int j=0; j<n-i-1; j++) {
                if(a[j] > a[j+1]){
                    int temp = a[j] ; a[j] = a[j+1] ;  a[j+1] = temp;
                }
            }
            print(a,n,i);
        }
        printResult(a,n);
    }
    /**
     * 打印排序的最终结果
     * @param a
     * @param n
     */
    private void printResult(int[] a, int n){
        System.out.print("最终排序结果：");
　　　　 for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
    /**
     * 打印排序的每次循环的结果
     * @param a
     * @param n
     * @param i
     */
    private void print(int[] a, int n, int i) {
        // TODO Auto-generated method stub
        System.out.print("第"+i+"次：");
        for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
}

　运行结果展示：

冒泡排序算法——改进一

　基本思想：

　　加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换。若无数据交换则说明数据已有序，可结束整个排序过程。

　Java实现

/**
 * 冒泡排序算法  改进 一
 */
private void bubbleSort1(int a[]){
    int n=a.length;
    boolean exchange;
    for(int i=0 ; i<n-1; i++) {
        exchange = false;
        for(int j=0; j<n-i-1; j++) {
            if(a[j] > a[j+1]){
                exchange = true;
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
            }
        }
    /**
     * 如果本次循环没进行数据交换，则跳出循环
     */
        if(exchange != true) break;
    }
}

冒泡排序算法——改进二

　基本思想：

　　设置标志性变量pos,用于记录每趟排序中最后一次交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

　Java实现

/**
 * 冒泡排序算法 改进二
 * @param a
 */
private void bubbleSort2(int a[]){
    int n=a.length;
    int i = n-1;
    while(i>0){
        /**
         * 每趟开始时,无记录交换
         */
        int pos = 0;
        for(int j=0; j<i; j++) {
            if(a[j] > a[j+1]){
                pos = j;
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
            }
        }
        i = pos;
    }
}

冒泡排序算法——改进三

　基本思想：

　　利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值（最大者和最小者）， 从而使排序趟数几乎减少了一半。

　Java实现

private void bubbleSort3(int a[]){
    int n=a.length;
    int low = 0;
    int high= n -1; //设置变量的初始值
    int tmp,j;
    while (low < high) {
        for(j=low; j<high; j++) //正向冒泡,找到最大者
            if (a[j] > a[j+1]) {
                tmp = a[j]; a[j]=a[j+1];a[j+1]=tmp;
            }
        --high;//修改high值, 前移一位  

        for(j=high; j>low; j--) //反向冒泡,找到最小者
            if (a[j]<a[j-1]) {
                tmp = a[j]; a[j]=a[j-1];a[j-1]=tmp;
            }
        ++low;                  //修改low值,后移一位
    }
}

（本文仅供学习交流，如有更好的思路，欢迎留下意见供大家探讨学习~）