數學模型
1. 近似
N3/6-N2/2+N/3 ~ N3/6。使用 ~f(N) 來表示所有隨着 N 的增大除以 f(N) 的結果趨近於 1 的函數。
2. 增長數量級
N3/6-N2/2+N/3 的增長數量級爲 O(N3)。增長數量級將算法與它的具體實現隔離開來，一個算法的增長數量級爲 O(N3) 與它是否用 Java 實現，是否運行於特定計算機上無關。
3. 內循環
執行最頻繁的指令決定了程序執行的總時間，把這些指令稱爲程序的內循環。
4. 成本模型
使用成本模型來評估算法，例如數組的訪問次數就是一種成本模型。
注意事項
1. 大常數
在求近似時，如果低級項的常數係數很大，那麼近似的結果是錯誤的。
2. 緩存
計算機系統會使用緩存技術來組織內存，訪問數組相鄰的元素會比訪問不相鄰的元素快很多。
3. 對最壞情況下的性能的保證
在覈反應堆、心臟起搏器或者剎車控制器中的軟件，最壞情況下的性能是十分重要的。
4. 隨機化算法
通過打亂輸入，去除算法對輸入的依賴。
5. 均攤分析
將所有操作的總成本除於操作總數來將成本均攤。例如對一個空棧進行 N 次連續的 push() 調用需要訪問數組的次數爲 N+4+8+16+…+2N=5N-4（N 是向數組寫入元素的次數，其餘都是調整數組大小時進行復制需要的訪問數組次數），均攤後訪問數組的平均次數爲常數。
ThreeSum
ThreeSum 用於統計一個數組中和爲 0 的三元組數量。
public interface ThreeSum {
int count(int[] nums);
}
1. ThreeSumSlow
該算法的內循環爲 if (nums[i] + nums[j] + nums[k] == 0) 語句，總共執行的次數爲 N(N-1)(N-2) = N3/6-N2/2+N/3，因此它的近似執行次數爲 ~N3/6，增長數量級爲 O(N3)。
public class ThreeSumSlow implements ThreeSum {
@Override
public int count(int[] nums) {
int N = nums.length;
int cnt = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
for (int k = j + 1; k < N; k++) {
if (nums[i] + nums[j] + nums[k] == 0) {
cnt++;
}
}
}
}
return cnt;
}
}
2. ThreeSumBinarySearch
將數組進行排序，對兩個元素求和，並用二分查找方法查找是否存在該和的相反數，如果存在，就說明存在和爲 0 的三元組。
應該注意的是，只有數組不含有相同元素才能使用這種解法，否則二分查找的結果會出錯。
該方法可以將 ThreeSum 算法增長數量級降低爲 O(N2logN)。
public class ThreeSumBinarySearch implements ThreeSum {
@Override
public int count(int[] nums) {
Arrays.sort(nums);
int N = nums.length;
int cnt = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
int target = -nums[i] - nums[j];
int index = BinarySearch.search(nums, target);
// 應該注意這裏的下標必須大於 j，否則會重複統計。
if (index > j) {
cnt++;
}
}
}
return cnt;
}
}
public class BinarySearch {
public static int search(int[] nums, int target) {
int l = 0, h = nums.length - 1;
while (l <= h) {
int m = l + (h - l) / 2;
if (target == nums[m]) {
return m;
} else if (target > nums[m]) {
l = m + 1;
} else {
h = m - 1;
}
}
return -1;
}
}
3. ThreeSumTwoPointer
更有效的方法是先將數組排序，然後使用雙指針進行查找，時間複雜度爲 O(N2)。
public class ThreeSumTwoPointer implements ThreeSum {
@Override
public int count(int[] nums) {
int N = nums.length;
int cnt = 0;
Arrays.sort(nums);
for (int i = 0; i < N - 2; i++) {
int l = i + 1, h = N - 1, target = -nums[i];
if (i > 0 && nums[i] == nums[i - 1]) continue;
while (l < h) {
int sum = nums[l] + nums[h];
if (sum == target) {
cnt++;
while (l < h && nums[l] == nums[l + 1]) l++;
while (l < h && nums[h] == nums[h - 1]) h--;
l++;
h--;
} else if (sum < target) {
l++;
} else {
h--;
}
}
}
return cnt;
}
}
倍率實驗
如果 T(N) ~ aNblogN，那麼 T(2N)/T(N) ~ 2b。
例如對於暴力的 ThreeSum 算法，近似時間爲 ~N3/6。進行如下實驗：多次運行該算法，每次取的 N 值爲前一次的兩倍，統計每次執行的時間，並統計本次運行時間與前一次運行時間的比值，得到如下結果：
| N | Time(ms) | Ratio |
|---|---|---|
| 500 | 48 | / |
| 1000 | 320 | 6.7 |
| 2000 | 555 | 1.7 |
| 4000 | 4105 | 7.4 |
| 8000 | 33575 | 8.2 |
| 16000 | 268909 | 8.0 |
可以看到，T(2N)/T(N) ~ 23，因此可以確定 T(N) ~ aN3logN。
public class RatioTest {
public static void main(String[] args) {
int N = 500;
int loopTimes = 7;
double preTime = -1;
while (loopTimes-- > 0) {
int[] nums = new int[N];
StopWatch.start();
ThreeSum threeSum = new ThreeSumSlow();
int cnt = threeSum.count(nums);
System.out.println(cnt);
double elapsedTime = StopWatch.elapsedTime();
double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
System.out.println(N + " " + elapsedTime + " " + ratio);
preTime = elapsedTime;
N *= 2;
}
}
}
public class StopWatch {
private static long start;
public static void start() {
start = System.currentTimeMillis();
}
public static double elapsedTime() {
long now = System.currentTimeMillis();
return (now - start) / 1000.0;
}
}