前言
哥德巴赫猜想是(Goldbach's Conjecture)是數論中存在最久的未解問題之一，是一個偉大的世界性的數學猜想，其基本思想可以陳述為：
任何一個大于2的偶數，都能表示成兩個素數之和。
如：
4 = 2 + 2
6 = 3 + 3
96= 23 + 73
本文將采用兩種不同的算法來求出給定范圍 n 內的哥德巴赫數字，并對比其時間復雜度，得出更優算法。
分析
根據哥德巴赫猜想，我們可以得出如下信息：
- 哥德巴赫數字是一個大于2的偶數。
- 哥德巴赫數字等于兩個素數相加。
思路A
思路A與之前見過的很多想法一樣，簡單粗暴，采用嵌套 for 循環。思路如下：
- for 循環依次遍歷 [4, n] 范圍內的偶數。
- 然后，針對每個數字（c）再次進行 for 循環找出兩個數字（a,b）之和等于該數字的數字。（即 c = a + b）
- 判斷 a,b 是否都為素數。
- 輸出結果。
Show the (garbage) code!
實現A
我們把思路A實現的程序分成兩個功能模塊：
-
判斷是否為素數模塊 int isPrime(int i)，返回 1 即為素數。
int isPrime(int i) { int j; if (i <= 1) return 0; if (i == 2) return 1; for (j = 2; j < i; j ++) { number ++; if (i % j == 0) { return 0; }else if(i != j + 1) { continue; }else { return 1; } } } -
主程序模塊：針對 [4, n] 之間的正偶數進行數值拆分，然后再用isPrime函數進行篩選，如果k，j都為素數，即滿足哥德巴赫猜想，輸出該數字。
do { printf("please enter a number:"); int number = 0; scanf("%d", &number); int i, j, k; for (int i = 4; i <= number; i += 2) { for (k = 2; k<= i/2; k ++) { j = i - k; if (isPrime(k)) { if (isPrime(j)) { printf("%d=%d+%d\n",i, k, j); } } } } }while (1);
思路B
遞歸算法，也是我業余時間自己寫的一個，遞歸路徑類似魚骨頭，基本思路如下：
- 針對輸入的 n 進行拆分（c = a + b 的形式）并遞歸。
- 如果拆分的數字 a,b 為偶數，則可能為符合哥德巴赫猜想，回到1。
- 如果 c 為偶數，且 a,b 為素數，即滿足哥德巴赫猜想，輸出該數字。
這里筆者畫了一張抽象的魚骨頭圖，幫助讀者理解：
實現B
思路B實現的程序主要分成三個功能模塊，為了區分思路A，判斷素數的模塊也采用遞歸的形式：
-
判斷是否為素數 int isPrime(int i)，返回 1 即為素數。
// 判斷偶數 int isEven(int original) { return (original % 2 == 0); } int isPrimeInner(int original, int current) { if (current<=0 || original<=0 || original == 1) return 0; if (original % 2 == 0) { if (original == 2) return 1; return 0; } if (current > (original / 2) + 1) return 1; if (original % current == 0 && current != 1) return 0; return isPrimeInner(original, current + 2); } // 判斷是否為偶數 int isPrime(int original) { return isPrimeInner(original, 1); } -
遞歸模塊
參數
current: 代表分裂初始值，參數flag: 代表是否深入遍歷，此處用于控制重復遍歷的情況，如：original=10 時，second=8 時，兩次會都會重復遍歷 6/4/2，因此加入flag進行限制，只進行一次深入遍歷！！void splitSumInner(int c, int current, int flag) { // 哥德巴赫為大于2的偶數 if (c <= 2) return; // 如果 current 大于 c 的一半，即代表遍歷完畢 if (current >= (c / 2) + 1) return; // 第一次分裂 c 數值 int a = current; int b = c - current; // 遞歸遍歷并分裂 c 數值 splitSumInner(c, ++ current, flag); // 判斷能否深入遍歷 if (flag && a > 2 && isEven(a)) { // 深入遍歷 分裂第一個子偶數 splitSum(a, 0); } if (flag && b > 2 && isEven(b)) { // 深入遍歷 分裂第二個子偶數 splitSum(b, 0); } // 如果 c 為偶數，且 a,b 為素數，即滿足哥德巴赫猜想，輸出該數字。 if (isEven(c) && isPrime(a) && isPrime(b)) { printf("\n%d=%d+%d\n",c, a, b); } } // original: 待分裂的原始數值（ps：會自動分裂 小于 original 下的所有數值） // flag: 1 代表分裂小于 original 下的所有數值；0 代表分裂當前 original 數值 void splitSum(int original, int flag) { splitSumInner(original, 1, flag); } -
主程序模塊
void goldbachConjecture(int n) { splitSum(n, 1); } int main() { do { printf("please enter a number:"); int number = 0; scanf("%d", &number); goldbachConjecture(number); } while (1); return 0; }
時間復雜度對比
時間復雜度說白了就是算法中基本操作的執行次數，更通俗的說法，就是最深層循環內的語句。基本操作的重復執行次數是和算法的執行時間成正比的。下面我們來粗略計算一下上述算法的時間復雜度。
A 算法分析
在程序 A 中，與下面的代碼相同，采用嵌套三層 for 循環的方式進行遍歷：
```
for (int i = 1; i <= n; i ++) { // 第一層循環
for (int j = 1; j <= i; j ++) { // 第二層循環
for (int k = 1; k <= j; k ++) { // 第三層循環
count ++;
printf("%d*%d*%d\n", i, j, k);
}
}
}
```
下面我們來剖析一下基本操作：
第一層 for 循環執行 n 次。
第二層 for 循環以 i 為規模分別執行 1,2,3,4......n-1,n 次，集一個公差為 1 的等差數列，總次數為 (n+1)*n/2。
-
第三層 for 循環采用排列組合來計算，舉個例子，當 n = 3 時，有 10 次基本操作，我們把執行路徑格式定義成 ijk，如下:
111 211 221 222 311 321 322 331 332 333
B 算法分析
結論
以上時間復雜度只是筆者通過簡單粗略的分析得出，僅供參考。通過上述分析，我們發現算法A與算法B時間復雜度是一樣的，感興趣的童鞋可以自己計算上述兩種算法的時間復雜度。筆者通過測試發現，相同的問題規模，隨著 n 的增大，算法B的時間復雜度要遠小于算法A。如：n = 100 時，算法B遍歷次數是 6380 次左右，算法A遍歷次數高達 15569 次（論算法糟糕的可怕性...）。源碼地址
