java數據結構——冒泡排序

數組：int score=[1, 8, 3, 7, 6, 9, 2, 10, 5, 4]

過程：1. 比較相鄰兩個數的大小
          2. 若左邊的數字大於右邊的數字，則交換兩個數字的位置（最大的值會被換到最右邊）
          3. 不然，向右移動一個位置，繼續比較
          4. 1~3爲一趟排序，共須要n-1趟排序

第一趟結果：1    3    7    6    8    2    9    5    4    10
第二趟結果：1    3    6    7    2    8    5    4    9    10
第三趟結果：1    3    6    2    7    5    4    8    9    10
第四趟結果：1    3    2    6    5    4    7    8    9    10
第五趟結果：1    2    3    5    4    7    7    8    9    10
第六趟結果：1    2    3    4    5    6    7    8    9    10
…… ……

代碼算法部分：

for (int i = score.length - 1 ; i > 0 ; i--) { // n-1趟排序
			
    for (int j = 0; j < i; j++) { // 對當前無序區間score[0......length-i-1]進行排序(j的範圍很關鍵，這個範圍是在逐步縮小的)
	if (score[j] > score[j + 1]) { // 把大的值交換到後面
	    int temp = score[j];
	    score[j] = score[j + 1];
	    score[j + 1] = temp;
	}
    }
			
    System.out.print("第" + (score.length - i) + "次排序結果：");
    for (int a = 0; a < score.length; a++) {
	System.out.print(score[a] + "\t");
    }
    System.out.println("");
}
		
System.out.print("最終排序結果：");
for (int a = 0; a < score.length; a++) {
    System.out.print(score[a] + "\t");
}

時間複雜度：

    第一趟進行了9次比較，第二趟進行了8次，第三趟進行了7次比較，以此類推
    則N個數比較次數之和是：(n-1) + (n-2) + ... + 2 + 1 = (n-1) * (n-2) / 2 ≈ n²
    綜上，冒泡算法的時間複雜度是O(N²)

Tips：不管什麼時候看到一個循環套在另外一個循環裏，則能夠懷疑它的時間複雜度是O(N²)，由於外層執行了N次，對於每一次，裏層無非是執行了N的幾分之幾回，能夠約爲N次。