冒泡排序

冒泡排序

---

1.原理

	比较两个相邻的数，将值大的数交换至右端。

1.1思路：

	依次比较相邻的两个数，将小数放在前面，大数放在后面。

	第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
	然后比较第2个数和第3个数，将小数放前，大数放后，
	如此继续，直至比较最后两个数，将小数放前，大数放后。
	重复第一趟步骤，直至全部排序完成。
	
	第一趟比较完成后，最后一个数一定是数组中最大的一个数，
	所以第二趟比较的时候最后一个数不参与比较。
	第二趟比较完成后，倒数第二个数也一定是数组中第二大的数
	，所以第三趟比较的时候最后两个数不参与比较。
	
	依次类推，每一趟比较次数-1。
	。。。。。。

1.2优化

	假设我们现在排序a[]={1,2,3,4,5,6,7,8,10,9}这组数据，按照上面的排序方式，
	第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。
	所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，
	说明这组数据已经有序，不用再继续下去。

---

2代码

2.1冒泡排序

	/**
     * 冒泡排序
     * @param a
     */
    private static void bubbleSort(int[] a) {
        int temp = 0;
        //外层循环控制排序趟数,内层循环控制每一趟排序多少次
        for (int j = 0; j < a.length - 1; j++) {
            //优化
            int flag = 0;
            for (int i = 0; i < a.length - 1 - j; i++) {
                if (a[i] > a[i + 1]) {
                    temp = a[i + 1];
                    a[i + 1] = a[i];
                    a[i] = temp;
                    //加入标记
                    flag = 1;
                }
            }
            //如果没有交换过元素，则已经有序
            if (flag == 0)
            {
                //输出排序后的数组
                toString(a);
                return;
            }
        }
    }
	

---

2.2完整java代码

	public class BubbleSort {
	
	    public static void main(String[] args) {
	        int a[] = { 2, 3, 6, 4, 0, 1, 7, 8, 5, 9 };
	        System.out.println("冒泡排序前的数组为:");
	        toString(a);
	        System.out.println("\n冒泡排序后的数组为:");
	        bubbleSort(a);
	    }
	
	    public static void toString(int[] a) {
	        for (int i = 0; i < a.length; i++) {
	            System.out.print(a[i]);
	        }
	    }
	
	    /**
	     * 冒泡排序
	     * @param a
	     */
	    private static void bubbleSort(int[] a) {
	        int temp = 0;
	        //外层循环控制排序趟数,内层循环控制每一趟排序多少次
	        for (int j = 0; j < a.length - 1; j++) {
	            //优化
	            int flag = 0;
	            for (int i = 0; i < a.length - 1 - j; i++) {
	                if (a[i] > a[i + 1]) {
	                    temp = a[i + 1];
	                    a[i + 1] = a[i];
	                    a[i] = temp;
	                    //加入标记
	                    flag = 1;
	                }
	            }
	            //如果没有交换过元素，则已经有序
	            if (flag == 0)
	            {
	                //输出排序后的数组
	                toString(a);
	                return;
	            }
	        }
	    }
	
	}

---

3时间复杂度和稳定性

	从代码中可以看出一共遍历了n-1 + n-2 + … + 2 + 1 = n * (n-1) / 2，那么时间复杂度是O(N^2)。
	又因为a[i]==a[i+1]的时候，不会移动a[i]和a[i+1]，所以冒泡排序是稳定的。