冒泡排序

冒泡排序是一种简单的快速排序。
基本思路：对一个有n个元素的数列进行排序。进行k趟排序，每一趟找出数列中最大的关键字(最简单的交换方式)，并将这个最大的关键字放在这一趟排序所遍历的最后一个位置上。其中要注意的是冒泡排序结束的条件是：在一趟排序过程中没有进行交换记录的操作。所以k值是由实际的序列来决定的。

例如：对序列49,38,65,97,76,13,27,49,55,4 进行起泡排序过程如下：
              第1趟：38 49 65 76 13 27 49 55 4 97
              第2趟：38 49 65 13 27 49 55 4 76 97
              第3趟：38 49 13 27 49 55 4 65 76 97
              第4趟：38 13 27 49 49 4 55 65 76 97
              第5趟：13 27 38 49 4 49 55 65 76 97
              第6趟：13 27 38 4 49 49 55 65 76 97
              第7趟：13 27 4 38 49 49 55 65 76 97
              第8趟：13 4 27 38 49 49 55 65 76 97
              第9趟：4 13 27 38 49 49 55 65 76 97
            第10趟：4 13 27 38 49 49 55 65 76 97

具体实现如下：

 

 

 

package Sort;
/*
 * 冒泡排序。注意两个循环的边界条件！
 * 冒泡排序结束的条件应该是"在一趟排序过程中没有进行交换记录的操作！"
 */
public class BubbleSort {
    private int[] array ;

    public BubbleSort(int[] array)
    {
        this.array = new int[array.length];
        this.array = array;
    }

    public void bubbleSort()
    {
        for(int i =0;i<array.length;i++)                       //i表示已经走过的趟数
        {

            for(int j=1;j<array.length-i;j++)                 //每趟要访问哪些元素
            {
                if(array[j-1]>array[j])
                {
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;

                }

            }
            for(int t=0;t<array.length;t++)
            {
                System.out.print(array[t]+"     ");
            }
            System.out.println();
        }
    }

    public void bubbleSort_better()
    {
        int count = -1;
        for(int i =0;count!=0;i++)                      //i表示已经走过的趟数;count表示交换次数为0就表示序列已排序好了。
        {
            count=0;
            for(int j=1;j<array.length-i;j++)          //每趟要访问哪些元素
            {
                if(array[j-1]>array[j])
                {
                    int tmp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = tmp;
                    count++;
                }

            }
            for(int t=0;t<array.length;t++)
            {
                System.out.print(array[t]+"     ");
            }
            System.out.println();
        }
    }

    public static void main(String args[])
    {
        int[] array = {49,38,65,97,76,13,27,49,55,4};
        int[] array2 = {23,24,25,26,27,28};
        BubbleSort bubblesortList = new BubbleSort(array2);
        bubblesortList.bubbleSort_better();
    }

 

 

bubbleSort()，bubbleSort_better()；上面代码中的这两个方法，均是冒泡排序的算法，不同的是前者要经过n趟排序；而后者的排序趟数是标记在一趟排序过程中没有进行交换记录的操作的count决定的。用在一趟排序过程中没有进行交换记录的操作作为循环结束的条件是合理：因为若一个数列本来就是一个有序数列，或者说只需要进行一两次的排序就能达到有序数列目的的时候，bubbleSort()仍然需要经过n趟排序，而bubbleSort_better()的趟数肯定是要小于n的。

冒泡排序的时间复杂度为O（n²）.

转自 http://blog.csdn.net/pigli/article/details/5747192