C语言--质数算法和最大公约数算法
文章目录
-
-
-
- 1.在C语言中，判断质数的常见算法有以下几种：
-
- 1.1.试除法（暴力算法）：
- 1.2.优化试除法：
- 1.3.埃拉托色尼筛法：
- 1.4.米勒-拉宾素性检验：
- 1.5.线性筛法：
- 1.6.费马小定理：
- 1.7.素性检验：
- 2.在C语言中，求两个数的最大公约数的常见算法有以下几种：
-
- 2.1.辗转相减法
- 2.2.辗转相除法
-
- 2.2.1.迭代实现：
- 2.2.2.递归实现：
- 2.3. `Stein`算法
- 2.4.`Lehmer`算法和`Schönhage-Strassen`算法
-
- 2.4.1.`Lehmer`算法
- 2.4.2. `Schönhage-Strassen`算法
-
-
1.在C语言中，判断质数的常见算法有以下几种：
试除法（暴力算法）：从2开始依次除以每个小于该数的自然数，如果有余数为0的，则该数不是质数。
优化试除法：只需要测试小于等于该数平方根的自然数，因为如果大于该数平方根的除数能整除该数，那么小于该数平方根的除数一定也能整除该数。
埃拉托色尼筛法：从2开始，将数字的倍数都标记为合数，就可以找到所有的质数。
米勒-拉宾素性检验：依靠不同的随机数，可以判断质数是否为合数，准确率高。
线性筛法：从小到大依次筛选质数，并标记其倍数为合数。
试除法（暴力算法）：
素性检验
1.1.试除法（暴力算法）：
#include 
1.2.优化试除法：
#include 
1.3.埃拉托色尼筛法：
#include 
1.4.米勒-拉宾素性检验：
#include 解释一下这里的测试次数k:
在算法中随机选择不同的基数进行多次检测。通过增加测试次数
k，可以提高算法的准确性，减少错误判定合数为质数的可能性。在每次测试中，随机选择不同的基数进行检测，如果所有测试都通过，那么被检测的数更有可能是质数。总之k的值决定了算法进行随机测试的次数，通过多次测试提高了判定质数的可靠性。（一般来说k的值选取范围是5-15）
1.5.线性筛法：
#include 
1.6.费马小定理：
费马小定理是一种用于判断质数的方法。如果一个数 n n n 是质数，且 a a a 是小于 n n n 的任意正整数，则 a n − 1 ≡ 1 ( m o d n ) a^{n-1} \equiv 1 \pmod n an−1≡1(modn)。
具体的判断方法为：随机选取一个整数 a a a，计算 a n − 1 m o d n a^{n-1} \bmod n an−1modn 的值，如果等于1，则 n n n 可能是质数。
但是，存在一些合数也满足费马小定理，即被称为费马伪素数。因此，费马小定理不是完全可靠的判断方法。需要进行多次测试，才能提高正确率。
下面是使用费马小定理进行判断的代码示例：
#include 
1.7.素性检验：
素性检验是一种比费马小定理更加精确的判断质数的方法，常用的有 Miller-Rabin 素性检验和 AKS 算法。
Miller-Rabin 素性检验已经在第四个示例中介绍过了，这里再介绍一下 AKS 算法。
AKS 算法是一种基于代数学理论的判断质数的算法，可以在多项式时间内实现。它的时间复杂度为 O ( log 12 n ) O(\log ^{12} n) O(log12n)，比 Miller-Rabin 算法还要慢，但是它的正确率非常高，可以判断非常大的质数。
AKS 算法的核心思想是利用柿子（binomial theorem）和模 p 下的同余关系，对多项式进行模运算，最终得到一个判断质数的结论。
这里不再给出 AKS 算法的代码实现，感兴趣的话可以自己百度一下。
2.在C语言中，求两个数的最大公约数的常见算法有以下几种：
- 辗转相减法
- 辗转相除法
- Stein算法
- 拓展
2.1.辗转相减法
辗转相减法也叫欧几里得算法，是求解两个正整数的最大公约数的一种简便算法，其基本思想是利用两数的差的绝对值不断递归，直到两数相等为止，此时所得的数即为最大公约数。
具体的实现过程为：
- 如果两个数相等，则它们的最大公约数即为它们本身；
- 如果其中一个数为0，则另一个数即为最大公约数；
- 如果两个数都不相等且都不为0，则将它们中较大的数减去较小的数，并用得到的差替换较大的数，然后回到第1步。
以下是使用辗转相减法求两个数的最大公约数的实现：
#include 
2.2.辗转相除法
辗转相除法（欧几里得算法）在C语言中的实现可以采用迭代或递归两种方式。
2.2.1.迭代实现：
#include 
2.2.2.递归实现：
#include 
2.3. Stein算法
Stein算法，也叫二进制 GCD 算法，是一种用于计算两个正整数的最大公约数的算法。它比辗转相除法更加高效，因为它的操作只涉及移位、加减运算和条件选择，消耗的时间和空间都比辗转相除法少。
具体的实现过程为：
- 把两个数都右移一位，直到两个数都为奇数；
- 如果a
- 计算d=a-b，如果d=0，则a即为最大公约数，结束；
- 把d右移一位，即d=d/2；
- 重复步骤3-4，直到d=1；
- 求出a和b的公共因子2的k次幂，即g=2^k，其中k是使a和b均为偶数的因子，把a和b都右移k位，此时就回到步骤1。
以下是使用Stein算法求两个数的最大公约数的实现：
#include Stein算法比辗转相减法和辗转相除法更加高效，特别是在处理大整数时。
2.4.Lehmer算法和Schönhage-Strassen算法
除了辗转相减法、辗转相除法和Stein算法外，还有更好的算法，例如，它们能够在O(N(logN)^2)的时间复杂度内计算出两个N位整数的最大公约数，但是实现起来比较复杂，需要涉及到高精度计算和复杂的数论知识。
Lehmer算法是一种基于欧几里得算法的改进算法，它利用了欧几里得算法的思想，但是通过一些优化使得执行次数更少，效率更高。它的基本思想是先对两个数进行预处理，然后再利用这些预处理结果进行计算。
Schönhage-Strassen算法是一种基于快速傅里叶变换的算法，它能够在O(N(logN)^2)时间复杂度内计算出两个N位整数的最大公约数。它的基本思想是把计算最大公约数的问题转化为计算多项式的问题，然后利用快速傅里叶变换进行多项式的乘法和除法。
2.4.1.Lehmer算法
下面是使用Lehmer算法求两个数的最大公约数的实现：
#include
#include
using namespace std;
// 求p^n
int pow(int p, int n)
{
int res = 1;
for (int i = 0; i < n; i++)
{
res *= p;
}
return res;
}
// 把n表示成p进制的形式，返回各个位的系数
vector convert(int n, int p)
{
vector digits;
while (n > 0)
{
digits.push_back(n % p);
n /= p;
}
return digits;
}
// Lehmer算法
int lehmer(int a, int b)
{
if (a == 0 || b == 0)
{
return a + b;
}
int p = 10, q = pow(p, 1.5);
vector r = convert(a, p), s = convert(b, p);
int n = r.size(), m = s.size();
while (m > 0)
{
int t = n - m;
int k = r[n - 1] * q + r[n - 2];
int l = s[m - 1] * q + s[m - 2];
if (r[n - 1] == s[m - 1] && k < l * q || k < l * q - 1)
{
t--;
k = (k + p * r[n - 3]) * p + r[n - 4];
}
int u = (k - l) % q * pow(p, t);
if (k < l)
{
u -= pow(p, t + 1);
}
r.erase(r.begin() + t, r.end());
for (int i = 0; i < m - 1; i++)
{
r[i] -= u * s[i];
if (r[i] < 0)
{
r[i] += p;
r[i + 1]--;
}
}
while (r.back() == 0)
{
r.pop_back();
}
n = r.size();
swap(r, s);
swap(m, n);
}
return s[0];
}
int main()
{
int a, b;
cout << "请输入两个数：";
cin >> a >> b;
int g = lehmer(a, b);
cout << a << " 和 " << b << " 的最大公约数是 " << g << endl;
return 0;
}
注意：
我这个windows上面的wsl没有装这个头文件，大家可以在ubuntu虚拟机里面试一试，这个有时间再弄
2.4.2. Schönhage-Strassen算法
下面是使用Schönhage-Strassen算法求两个数的最大公约数的实现：
#include
#include
#include
#include
using namespace std;
const double PI = acos(-1);
typedef complex comp;
void bit_reverse_copy(const vector& a, vector& b)
{
int n = a.size();
int p = 0;
for (int i = 0; i < n; i++)
{
b[p] = a[i];
for (int j = n / 2; (p ^= j) < j; j /= 2);
}
}
// 快速傅里叶变换
void fft(vector& a, int inv)
{
int n = a.size();
vector b(n);
bit_reverse_copy(a, b);
for (int h = 1; h < n; h <<= 1)
{
for (int j = 0; j < n; j += h << 1)
{
comp w(1, 0);
for (int k = 0; k < h; k++)
{
comp t = w * b[j + k + h];
b[j + k + h] = b[j + k] - t;
b[j + k] += t;
w *= comp(cos(PI * inv * k / h), sin(PI * inv * k / h));
}
}
}
if (inv == -1)
{
for (int i = 0; i < n; i++)
{
b[i] /= n;
}
}
a.swap(b);
}
// 计算两个N位整数的最大公约数
int ss_gcd(string a, string b)
{
int n = a.size(), m = b.size();
int N = 1;
while (N < n + m)
{
N <<= 1;
}
vector A(N), B(N);
for (int i = 0; i < n; i++)
{
A[i] = a[n - 1 - i] - '0';
}
for (int i = 0; i < m; i++)
{
B[i] = b[m - 1 - i] - '0';
}
fft(A, 1);
fft(B, 1);
vector C(N);
for (int i = 0; i < N; i++)
{
C[i] = A[i] * B[i];
}
fft(C, -1);
reverse(C.begin() + 1, C.end());
while (C.size() > 1 && C.back().real() == 0)
{
C.pop_back();
}
string r;
for (int i = C.size() - 1; i >= 0; i--)
{
r += char(C[i].real() + 0.5) + '0';
}
while (r.size() > 1 && r.back() == '0')
{
r.pop_back();
}
return stoi(r);
}
int main()
{
string a, b;
cout << "请输入两个数：";
cin >> a >> b;
int g = ss_gcd(a, b);
cout << a << " 和 " << b << " 的最大公约数是 " << g << endl;
return 0;
}
注意：
我这个windows上面的wsl没有装这个头文件，大家可以在ubuntu虚拟机里面试一试