冒泡排序

冒泡排序的核心思想是：从第一个元素开始，往后比较，遇到比自己小的元素就交换位置，交换的次数最多，自然也是性能最差的。
排序过程：
假设数组长度为n。
1．比较数组中前后相邻的两个数据，如果前面数据大于后面的数据，就将两个数据交换。
2．这样对数组的第0个数据到第n-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第n-1个位置。
3．此时n=n-1，重复前面两步，直到排序完成。
Java代码实现：

package bubble;

public class bubble1 {
    public static int[] bubble(int [] arr)
    {
        int temp=0;
        //控制循环的次数
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=0;j<arr.length-i-1;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
            System.out.println("第"+(i+1)+"次排序结果:");
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]+" ");
            }
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] arr={19,1,6,2,9,5,4,7,6};
        int [] arr1=bubble(arr);
        System.out.println();
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }
    }
}

结果为：
第1次排序结果:
1 6 2 9 5 4 7 6 19
第2次排序结果:
1 2 6 5 4 7 6 9 19
第3次排序结果:
1 2 5 4 6 6 7 9 19
第4次排序结果:
1 2 4 5 6 6 7 9 19
第5次排序结果:
1 2 4 5 6 6 7 9 19
第6次排序结果:
1 2 4 5 6 6 7 9 19
第7次排序结果:
1 2 4 5 6 6 7 9 19
第8次排序结果:
1 2 4 5 6 6 7 9 19

1 2 4 5 6 6 7 9 19
冒泡排序是一个稳定的排序，
最好的时间复杂度为O(n)
最坏的时间复杂度为O(n*n)
平均时间复杂度为O(n*n)

可以设置标志位改进冒泡法：

package bubble;

public class bubble2 {
    public static int [] bubble(int [] arr)
    {
        int j=0;
        int k=arr.length;
        int temp=0;
        boolean flag=true;
        //设置标志位，初始化为true,假如在一趟循环中，没有发生两两交换，则flag为false,证明排序结束，不需要进行下一次循环，这样可以减少循环次数的次数。
        while(flag)
        {
            flag=false;
            for(j=1;j<k;j++)
            {
                if(arr[j-1]>arr[j])
                {
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                    flag=true;
                }
            }
            k--;

            System.out.println("第"+(arr.length-k)+"次排序：");
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]+" ");
            }
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        //(1)int []arr={1,3,5,23,25,26,27,28};
        //(2)int [] arr={2,5,4,14,12,10,32,1};
        int []arr1=bubble(arr);
        System.out.println();
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }
    }
}

当原始数组为（1）处的数组时，结果为：
第1次排序：
1 3 5 23 25 26 27 28

1 3 5 23 25 26 27 28
当原始数组为（2）处的数组时，结果为：
第1次排序：
2 4 5 12 10 14 1 32
第2次排序：
2 4 5 10 12 1 14 32
第3次排序：
2 4 5 10 1 12 14 32
第4次排序：
2 4 5 1 10 12 14 32
第5次排序：
2 4 1 5 10 12 14 32
第6次排序：
2 1 4 5 10 12 14 32
第7次排序：
1 2 4 5 10 12 14 32
第8次排序：
1 2 4 5 10 12 14 32

1 2 4 5 10 12 14 32