哥德巴赫猜想c语言 思路,01-哥德巴赫猜想(Goldbach's Conjecture)--(C语言)
goldbach-partitions-of-the-even.png
前言
哥德巴赫猜想是(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 為素數，即滿足哥德巴赫猜想，輸出該數字。
這里筆者畫了一張抽象的魚骨頭圖，幫助讀者理解：
goldbach-conjecture-fish.png
實現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
algorithm-analyze-a.png
B 算法分析
algorithm-analyze-b.png
結論
以上時間復雜度只是筆者通過簡單粗略的分析得出，僅供參考。通過上述分析，我們發現算法A與算法B時間復雜度是一樣的，感興趣的童鞋可以自己計算上述兩種算法的時間復雜度。筆者通過測試發現，相同的問題規模，隨著 n 的增大，算法B的時間復雜度要遠小于算法A。如：n = 100 時，算法B遍歷次數是 6380 次左右，算法A遍歷次數高達 15569 次(論算法糟糕的可怕性...)。源碼地址
總結
以上是生活随笔為你收集整理的哥德巴赫猜想c语言 思路,01-哥德巴赫猜想(Goldbach's Conjecture)--(C语言)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 数据中台到底是什么？
- 下一篇： 第八届蓝桥杯大赛个人赛决赛（CB软件类）