算法：java冒泡排序算法

1.    基本思想

待排序元素从左向右两两相互比较，大的放后边，小的放前边，一趟排序下来最后一个既就是最大的数，第二趟排序的时候由于最后一个数已经是最大的，所以可以比较前边n-1个，同样大的在后，小的在前，第二趟下来后边2个元素已经按照从小到大顺序有序，以此类推，每次冒出一个最大的数。

同样，若排序是从大到小，那么小的在后，大的数在前，每次冒出一个最小的数。

2.    算法示例

待排序元素：        23  13  14 13  45  12  8  5 41  3

第一趟的第1次排序：13  23  14  13 45  12  8  5  41  3

第一趟的第2次排序：13  14  23 13  45  12 8  5  41  3

第一趟的第3次排序：13  14  13  23 45  12  8 5  41  3

第一趟的第4次排序：13  14  13  23  45  12 8  5  41  3

第一趟的第5次排序：13  14  13  23  12  45 8  5  41  3

第一趟的第6次排序：13  14  13  23  12  8  45  5  41  3

第一趟的第7次排序：13  14  13  23  12  8  5  45  41  3

第一趟的第8次排序：13  14  13  23  12  8  5  41  45 3

第一趟的第9次排序：13  14  13  23  12  8  5  41  3  45

第二趟的第1次排序：13  14  13  23  12  8  5  41  3  45

第二趟的第2次排序：13 13  14  23  12  8  5  41  3  45

第二趟的第3次排序：13  13  14  23  12  8  5  41  3  45

第二趟的第4次排序：13  13  14  12  23 8  5  41  3  45

第二趟的第5次排序：13  13  14  12  8  23  5  41  3  45

第二趟的第6次排序：13  13  14  12  8  5  23 41  3  45

第二趟的第7次排序：13  13  14  12  8  5  23  41  3  45

第二趟的第8次排序：13  13  14  12  8  5  23  3  41 45

………………………..

 

3.    算法实现

package sort;

 

public classBubleSort {

     int a[] = { 34, 25, 43, 56,12, 3, 1, 98, 78 };

     int temp = 0;

     int i = 0;

     int j = 0;

 

     // 由小到大排序，每次冒出一个最大的数

     public void buble() {

           for (i = 0; i < a.length - 1; i++) {

                for (j = 0; j < a.length - 1 - i; j++) {

                     if (a[j] > a[j + 1]) {

                           temp = a[j + 1];

                           a[j + 1] = a[j];

                           a[j] = temp;

                     }

 

                }

 

           }

           for (i = 0; i <= a.length - 1; i++) {

                System.out.println(a[i]);

           }

           System.out.println(' ');

 

     }

// 由大到小排序，每次冒出一个最小的数

     public void bublen() {

           for (i = 0; i < a.length - 1; i++) {

                for (j = 0; j < a.length - 1 - i; j++) {

                     if (a[j] < a[j + 1]) {

                           temp = a[j];

                           a[j] = a[j + 1];

                           a[j + 1] = temp;

                     }

                }

           }

 

           for (i = 0; i <= a.length - 1; i++) {

                System.out.println(a[i]);

           }

 

     }

 

     public static void main(String args[]) {

           BubleSortb = newBubleSort();

           b.buble();

           b.bublen();

 

     }

 

}

 

4.    算法分析

我们从算法的稳定性、复杂性、应用场景来分析冒泡算法。

稳定性指的是，若待排序元素中两个数值大小相同d的r[i],r[j]，排完序之后，r[i]仍在r[j]前面，那么此算法就是稳定的。

 

冒泡算法两两比较，若是从小到大排序，那么两两比较之后，大的在后，小的在前，数值一样的保持位置不变，所以冒泡排序算法是稳定的。

 

复杂度分析：两个循环，那么时间复杂度是0(n²)；在排序过程中借助临时元素，所以空间复杂度0(1)。

 

应用场景：由于复杂度为0(n²),所以当待排序元素较少，也就是n较小时，用冒泡排序算法比较快，也比较简单。