47244人阅读
Algorithm & Data Structure（6）
x%y为x取模y，即x除以y所得的余数，当x&y时，x%y=x，所有取模的运算对象都为整数。
x^y表示x的y次方。乘方运算的优先级高于乘除和取模，加减的优先级最低。
见到x^y/z这样，就先算乘方，再算除法。
A/B，称为A除以B，也称为B除A。
若A%B=0，即称为A可以被B整除，也称B可以整除A。
A*B表示A乘以B或称A乘B，B乘A，B乘以A……都一样。
复习一下小学数学
公因数：两个不同的自然数A和B，若有自然数C可以整除A也可以整除B，那么C就是A和B的公因数。
公倍数：两个不同的自然数A和B，若有自然数C可以被A整除也可以被B整除，那么C就是A和B的公倍数。
互质数：两个不同的自然数，它们只有一个公因数1，则称它们互质。
费马是法国数学家，又译“费尔马”，此人巨牛，他的简介请看下面。不看不知道，一看吓一跳。
费马人物简介：　　
2.费马小定理：
有N为任意正整数，P为素数，且N不能被P整除（显然N和P互质），则有：N^P%P=N(即：N的P次方除以P的余数是N)。
但是我查了很多资料见到的公式都是这个样子：
(N^(P-1))%P=1后来分析了一下，两个式子其实是一样的，可以互相变形得到。
原式可化为：(N^P-N)%P=0(即：N的P次方减N可以被P整除，因为由费马小定理知道N的P次方除以P的余数是N)把N提出来一个，N^P就成了你N*(N^(P-1))，那么(N^P-N)%P=0可化为：
(N*(N^(P-1)-1))%P=0
请注意上式，含义是：N*(N^(P-1)-1)可以被P整除
又因为N*(N^(P-1)-1)必能整除N（这不费话么!）
所以，N*(N^(P-1)-1)是N和P的公倍数，小学知识了^_^
又因为前提是N与P互质，而互质数的最小公倍数为它们的乘积，所以一定存在
正整数M使得等式成立：N*(N^(P-1)-1)=M*N*P
两边约去N，化简之：N^(P-1)-1=M*P
因为M是整数，显然：N^(P-1)-1)%P=0即：N^(P-1)%P=1
============================================
3.积模分解公式
先有一个引理，如果有：X%Z=0，即X能被Z整除，则有：(X+Y)%Z=Y%Z
设有X、Y和Z三个正整数，则必有：(X*Y)%Z=((X%Z)*(Y%Z))%Z
想了很长时间才证出来，要分情况讨论才行：
1.当X和Y都比Z大时，必有整数A和B使下面的等式成立：
X=Z*I+A（1）
Y=Z*J+B（2）
不用多说了吧，这是除模运算的性质！
将（1）和（2）代入(X*Y)modZ得：((Z*I+A)(Z*J+B))%Z乘开，再把前三项的Z提一个出来，变形为：(Z*(Z*I*J+I*A+I*B)+A*B)%Z（3）
因为Z*(Z*I*J+I*A+I*B)是Z的整数倍……晕，又来了。
概据引理，（3）式可化简为：(A*B)%Z又因为：A=X%Z，B=Y%Z，代入上面的式子，就成了原式了。
2.当X比Z大而Y比Z小时，一样的转化：
X=Z*I+A
代入(X*Y)%Z得：
(Z*I*Y+A*Y)%Z
根据引理，转化得：(A*Y)%Z
因为A=X%Z，又因为Y=Y%Z，代入上式，即得到原式。
同理，当X比Z小而Y比Z大时，原式也成立。
3.当X比Z小，且Y也比Z小时，X=X%Z，Y=Y%Z，所以原式成立。
=====================================================
4.快速计算乘方的算法
如计算2^13，则传统做法需要进行12次乘法。
/*计算n^p*/
unsigned power(unsigned n,unsigned p)
for(int i=0;i&p;i++) n*=n;
该死的乘法，是时候优化一下了！把2*2的结果保存起来看看，是不是成了：
4*4*4*4*4*4*2
再把4*4的结果保存起来：16*16*16*2
一共5次运算，分别是2*2、4*4和16*16*16*2
这样分析，我们算法因该是只需要计算一半都不到的乘法了。
为了讲清这个算法，再举一个例子2^7：2*2*2*2*2*2*2
两两分开：(2*2)*(2*2)*(2*2)*2
如果用2*2来计算，那么指数就可以除以2了，不过剩了一个，稍后再单独乘上它。
再次两两分开，指数除以2： ((2*2)*(2*2))*(2*2)*2
实际上最后一个括号里的2 * 2是这回又剩下的，那么，稍后再单独乘上它 现在指数已经为1了，可以计算最终结果了：16*4*2=128
优化后的算法如下：
unsigned Power(unsigned n,unsigned p)
unsigned main=n; //用main保存结果
unsigned odd=1; //odd用来计算“剩下的”乘积
while (p&1)
{//一直计算，直到指数小于或等于1
if((p%2)!=0)
{// 如果指数p是奇数，则说明计算后会剩一个多余的数，那么在这里把它
乘到结果中
odd*= //把“剩下的”乘起来
main*= //主体乘方
p/=2; //指数除以2
return main* //最后把主体和“剩下的”乘起来作为结果
够完美了吗？不，还不够！看出来了吗？main是没有必要的，并且我们可以有更快的代码来判断奇数。要知道除法或取模运算的效率很低，所以我们可以利用偶数的一个性质来优化代码，那就是偶数的二进制表示法中的最低位一定为0!
unsigned Power(unsigned n, unsigned p)
{ // 计算n的p次方
unsigned odd = 1; //oddk用来计算“剩下的”乘积
while (p & 1)
{ // 一直计算到指数小于或等于1
if (( p & 1 )!=0)
{ // 判断p是否奇数，偶数的最低位必为0
odd *= // 若odd为奇数，则把“剩下的”乘起来
n *= // 主体乘方
p /= 2; // 指数除以2
return n * // 最后把主体和“剩下的”乘起来作为结果
========================================================
5.&蒙格马利”快速幂模算法
后面我们会用到这样一种运算：(X^Y)%Z。但问题是当X和Y很大时，只有32位的整型变量如何能够有效的计算出结果？
考虑上面那份最终的优化代码和再上面提到过的积模分解公式，我想你也许会猛拍一下脑门，吸口气说：“哦，我懂了！”。
下面的讲解是给尚没有做出这样动作的同学们准备的：
X^Y可以看作Y个X相乘，即然有积模分解公式，那么我们就可以把Y个X相乘再取模的过程分解开来，比如：(17^25)%29则可分解为：(
( 17 * 17 ) % 29 * ( 17 * 17 ) % 29 * ……
如果用上面的代码将这个过程优化，那么我们就得到了著名的“蒙格马利”快速幂模算法：
unsigned Montgomery(unsigned n, unsigned p, unsigned m)
{ // 快速计算 (n ^ e) % m 的值，与power算法极类似
unsigned r = n % // 这里的r可不能省
unsigned k = 1;
while (p & 1)
if ((p & 1)!=0)
k = (k * r) % // 直接取模
r = (r * r) % // 同上
return (r * k) % // 还是同上
上面的代码还可以优化。下面是蒙格马利极速版：
unsigned Montgomery(unsigned n,unsigned p,unsigned m)
{ //快速计算(n^p)%m的值
unsignedk=1;
while(p!=1)
if(0!=(p&1))k=(k*n)%m;
n=(n*n)%m;
return(n*k)%m;
=====================================================
6.怎么判断一个数是否为素数？
1)笨蛋的作法：
bool IsPrime(unsigned n)
//小于2的数即不是合数也不是素数
for (unsigned i=2;i&n;++i)
//和比它小的所有的数相除，如果都除不尽，证明素数
if (n%i==0)
//除尽了，则是合数
}一个数去除以比它的一半还要大的数，一定除不尽，所以还用判断吗？？
2)下面是小学生的做法：
bool IsPrime(unsigned n)
//小于2的数即不是合数也不是素数
for(unsigned i=2;i&n/2+1;++i)
// 和比它的一半小数相除，如果都除不尽，证明素数
if ( 0 == n % i )
// 除尽了，合数
// 都没除尽，素数
一个合数必然可以由两个或多个质数相乘而得到。那么如果一个数不能被比它的一半小的所有的质数整除，那么比它一半小的所有的合数也一样不可能整除它。建立一个素数表是很有用的。
3)下面是中学生的做法：
bool IsPrime2(unsigned n)
if ( n & 2 )
{ // 小于2的数即不是合数也不是素数
static unsigned aPrimeList[] = { // 素数表
1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 113,
193, 241, 257, 337, 353, 401, 433, 449, 577, 593, 641,
673, 769, 881, 929, 977, , , 1249,
, , , , 1873,
, , , , 2593,
, , , , 3089,
, , , , 3617,
, , , , 4241,
, , , , 4721,
, , , , 5393,
, , , , 6353,
, , , , 6961,
, , , , 7649,
, , , , 8209,
, , , , 8753,
, , , , 9601,
const int nListNum = sizeof(aPrimeList)/sizeof(unsigned);//计算素数表里元素的个数
for (unsigned i=2;i&nListN++i )
if(n/2+1&aPrimeList[i])
if(0==n%aPrimeList[i])
/*由于素数表中元素个数是有限的，那么对于用素数表判断不到的数，就只有用笨蛋办法了*/
for (unsigned i=aPrimeList[nListNum-1];i&n/2+1;i++ )
if (0==n%i)
// 除尽了，合数
}& & & & 还是太糟了，我们现在要做的对于大型素数的判断，那个素数表倒顶个P用！当然，我们可以利用动态的素数表来进行优化，这就是大学生的做法了。但是动态生成素数表的策略又复杂又没有效率，所以我们还是直接跳跃到专家的做法吧：
& & & & 根据上面讲到的费马小定理，对于两个互质的素数N和P，必有：N^(P-1)%P=1 ,那么我们通过这个性质来判断素数吧，当然，你会担心当P很大的时候乘方会很麻烦。不用担心！我们上面不是有个快速的幂模算法么？好好的利用蒙格马利这位大数学家为我们带来的快乐吧！
算法思路是这样的：
& & & & 对于N，从素数表中取出任意的素数对其进行费马测试，如果取了很多个素数，N仍未测试失败，那么则认为N是素数。当然，测试次数越多越准确，但一般来讲50次就足够了。另外，预先用“小学生”的算法构造一个包括500个素数的数组，先对Q进行整除测试，将会大大提高通过率，方法如下:
6)下面是专家的做法：
bool IsPrime3(unsigned n)
if ( n & 2 )
// 小于2的数即不是合数也不是素数
static unsigned aPrimeList[] = {
2, 3, 5, 7, 11, 17, 19, 23, 29, 31, 41,
43, 47, 53, 59, 67, 71, 73, 79, 83, 89, 97
const int nListNum = sizeof(aPrimeList) / sizeof(unsigned);
for (int i=0;i&nListN++i)
// 按照素数表中的数对当前素数进行判断
if (1!=Montgomery(aPrimeList[i],n-1,n)) // 蒙格马利算法
}& & & & OK，这就专家的作法了。
& & & & 等等，什么？好像有点怪，看一下这个数29341，它等于13 * 37 * 61，显然是一个合数，但是竟通过了测试！！哦，抱歉，我忘了在素数表中加入13，37，61这三个数，我其实是故意的，我只是想说明并费马测试并不完全可靠。
& & & & 现在我们发现了重要的一点，费马定理是素数的必要条件而非充分条件。这种不是素数，但又能通过费马测试的数字还有不少，数学上把它们称为卡尔麦克数，现在数学家们已经找到所有10
^ 16以内的卡尔麦克数，最大的一个是3329。我们必须寻找更为有效的测试方法。数学家们通过对费马小定理的研究，并加以扩展，总结出了多种快速有效的素数测试方法，目前最快的算法是拉宾米勒测试算法，下面介绍拉宾米勒测试。
================================================================
7.拉宾米勒测试
& & & & 拉宾米勒测试是一个不确定的算法，只能从概率意义上判定一个数可能是素数，但并不能确保。算法流程如下:
& & & &1.选择T个随机数A，并且有A&N成立。
& & & &2.找到R和M，使得N=2*R*M+1成立。
& & & &快速得到R和M的方式：N用二进制数B来表示，令C=B-1。因为N为奇数（素数都是奇数），所以C的最低位为0，从C的最低位的0开始向高位统计，一直到遇到第一个1。这时0的个数即为R，M为B右移R位的值。
& & & &3.如果A^M%N=1，则通过A对于N的测试，然后进行下一个A的测试
& & & &4.如果A^M%N!=1，那么令i由0迭代至R，进行下面的测试
& & & &5.如果A^((2^i)*M)%N=N-1则通过A对于N的测试，否则进行下一个i的测试&
& & & &6.如果i=r，且尚未通过测试，则此A对于N的测试失败，说明N为合数。
& & & &7.进行下一个A对N的测试，直到测试完指定个数的A
& & & &通过验证得知，当T为素数，并且A是平均分布的随机数，那么测试有效率为1 / ( 4 ^ T )。如果T & 8那么测试失误的机率就会小于10^(-5)，这对于一般的应用是足够了。如果需要求的素数极大，或着要求更高的保障度，可以适当调高T的值。
下面是代码：
bool RabbinMillerTest( unsigned n )
// 小于2的数即不是合数也不是素数
const unsigned nPrimeListSize=sizeof(g_aPrimeList)/sizeof(unsigned);//求素数表元素个数
for(int i=0;i&nPrimeListS++i)
// 按照素数表中的数对当前素数进行判断
if (n/2+1&=g_aPrimeList[i])
// 如果已经小于当前素数表的数，则一定是素数
if (0==n%g_aPrimeList[i])
// 余数为0则说明一定不是素数
// 找到r和m，使得n = 2^r * m + 1;
int r = 0, m = n - 1; // ( n - 1 ) 一定是合数
while ( 0 == ( m & 1 ) )
m &&= 1; // 右移一位
r++; // 统计右移的次数
const unsigned nTestCnt = 8; // 表示进行测试的次数
for ( unsigned i = 0; i & nTestC ++i )
// 利用随机数进行测试，
int a = g_aPrimeList[ rand() % nPrimeListSize ];
if ( 1 != Montgomery( a, m, n ) )
int j = 0;
int e = 1;
for ( ; j & ++j )
if ( n - 1 == Montgomery( a, m * e, n ) )
if (j == r)
以上内容载自博客园并稍加编辑：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：84948次
排名：千里之外
原创：28篇
评论：46条
(2)(4)(8)(15)下载作业帮安装包
扫二维码下载作业帮
1.75亿学生的选择
判断一个数是否为素数的算法判断一个数n是不是素数，我只知道有这个方法：让n除以2到n的平方根之间的每一个数，如果n能被2到n的平方根之间的某个数整除，则说明n不是素数，否则n一定是素数。（n大于2）但是我在一个程序上又看到了另一种算法，就是让n除以2到n/2之间的每一个数，如果都除不尽，那这个数就是素数。原先那个方法我知道是什么思路的，可是这个方法……是什么原因呢？为什么是除以2到n/2呢？
因为没必要去比较大于n/2的情况，因为n=2*n/2，假设m>n/2，那么n必然不能被m整除，就好像100=2*50，不需要再去比较51,52....
为您推荐：
扫描下载二维码&&/&&&&/&&&&/&&
素数又称质数。所谓素数是指除了1和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被2~16的任一整数整除。
思路1)：因此判断一个整数m是否是素数，只需把m被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么m就是一个素数。
思路2)：另外判断方法还可以简化。m不必被 2 ~ m-1 之间的每一个整数去除，只需被 2 ~
之间的每一个整数去除就可以了。如果m不能被 2 ~&间任一整数整除，m必定是素数。例如判别17是是否为素数，只需使17被2~4之间的每一个整数去除，由于都不能整除，可以判定17是素数。
原因：因为如果m能被 2 ~ m-1 之间任一整数整除，其二个因子必定有一个小于或等于，另一个大于或等于。例如16能被2,4,8整除，16=2*8，2小于4，8大于4，16=4*4，4=&16，因此只需判定在2~4之间有无因子即可。
两种思路的代码请看解析。
思路1)的代码：
#include &stdio.h&
int main(){
// 素数的个数
int num=0;
// 输入的整数
printf(&输入一个整数：&);
scanf(&%d&,&num);
for(int i=2;i&i++){
if(num%i==0){
// 素数个数加1
printf(&%d是素数。\n&, num);
printf(&%d不是素数。\n&, num);
思路2)的代码：
#include &stdio.h&
#include &math.h&
void main(){
// 输入的整数
// 循环次数
// m 的平方根
printf(&输入一个整数：&);
scanf(&%d&,&m);
// 求平方根，注意sqrt()的参数为 double 类型，这里要强制转换m的类型
k=(int)sqrt( (double)m );
for(i=2;i&=k;i++)
if(m%i==0)
// 如果完成所有循环，那么m为素数
// 注意最后一次循环，会执行i++，此时 i=k+1，所以有i&k
printf(&%d是素数。\n&,m);
printf(&%d不是素数。\n&,m);
两段代码的输出结果相同。
第一次运行结果：
第二次运行结果：
第三次运行结果：千里之行 始于足下精诚所至 金石为开
欢迎加入我们，一同切磋技术。 &
用户名： &&&
密　码： &
共有 10203 人关注过本帖
标题：判断一个数是否是素数
等　级：新手上路
结帖率：100%
&&已结贴√
&&问题点数：20&&回复次数：10&&&
判断一个数是否是素数
#include &math.h&
int su(long x)
&&& if(x%2==0)&&& return 0;
&&&&&&&&for(i=3;i&sprt(x);i+=2)
&&&&&&&&&&&&if(x%i==0)&&& return 0;
&&& return 1;
搜索更多相关主题的帖子:
来　自：莉莉斯
等　级：论坛游侠
帖　子：222
专家分：107
？？？？？ 想表达什么~？...... 哦 ~素数 ~
零波 丽 疑惑道
人又是什么？神造出来的东西。 人是人造出来的东西。
等　级：蜘蛛侠
帖　子：229
专家分：1027
hehe,把主函数也给出来吧
等　级：业余侠客
帖　子：104
专家分：253
其实是判断素数，若是就返回1，否则就返回0，先看能不能被2整出，若整除肯定不是素数，如不整除就看它能不能被3,5,7,9。。。一直到sprt(x)，整除。若整除就不是素数，还有应该是 sqrt不是p
来　自：广东潮州
等　级：小飞侠
帖　子：1181
专家分：2784
代码有问题
一步一个脚印...............................默默地前进.....
诚邀乐于解答c菜鸟问题，的热心网友加入，&&QQ群
来　自：广东潮州
等　级：小飞侠
帖　子：1181
专家分：2784
去看看（sqrt）函数原型就懂了
一步一个脚印...............................默默地前进.....
诚邀乐于解答c菜鸟问题，的热心网友加入，&&QQ群
等　级：论坛游民
帖　子：46
专家分：35
用这么麻烦的方法求啊~&&没见过，这种算法正确么？
我觉得直接从2到n-1判断一遍简单些
等　级：新手上路
&&&&&&&&&&&素数即质数&&&&&&&&& 代码有问题
来　自：北京
等　级：贵宾
威　望：94
帖　子：6779
专家分：16751
回复 2楼 零波丽
好久没看见这么说话的了～～
等　级：新手上路
&&#include&stdio.h&
&&#include&math.h&
&&int main()
&&&int a,b;
&&&scanf(&%d&,&a);
&&&for(b=1,b&sprt(a),b++);
&&&if(a%b=0)
&&&printf(&a not 素数&);
&&&else printf(&a is 素数&);
&&&return 0;
版权所有，并保留所有权利。
Powered by , Processed in 0.022259 second(s), 8 queries.
Copyright&, BCCN.NET, All Rights Reserved