判断一个数字是否为质数（素数）！

---------首先要知道质数的定义。
质数：只能被1或者自身整除的数字，0和1都不是质数。
思路：利用循环进行多次判断，具体我在下面的代码中都有解释。大家可以看看，有别的想法也可以提出来一起讨论。

#include<stdio.h>
int main(){
	int num,i,count=0;
	printf("请输入一个整数:");
	scanf("%d",&num);
	if(num==0){
		printf("%d不是一个质数!",num);	
	}
	for(i=2;i<=num/2;i++){
		if(num%i==0){
			count++;
			break;
		}
	}
	if(num!=1 && count==0){
		printf("%d是一个质数!\n",num);	
	}else{
		printf("%d不是一个质数!\n",num);	
	}
	return 0;	
}

我这个代码是在Linux下运行的，如果要在C-Free5运行的话输出会有乱码。将输入和输出的中文改成英文即可。代码如下：

#include<stdio.h>
int main(){
	int num,i,count=0;//定义变量并且赋值 ，count记录这些数字有没有能够整除num的 
	printf("Enter a number:");
	scanf("%d",&num);//读入数据 
	if(num==0){
		printf("%d不是一个质数!",num);	
	}//0不是质数，所以判断输入的数字是否为0 
	for(i=2;i<=num/2;i++){//循环，因为1不是质数，所以i从2开始循环，i要小于num/2 
		if(num%i==0){//判断num能否被整除 
			count++;//若可以，加1 
			break;//直接跳出循环，已经找到一个，没有必要再继续循环了 
		}
	}
	if(num!=1 && count==0){//判断是否满足质数的条件 
		printf("%d is a zhishu!\n",num);	
	}else{
		printf("%d isn't a zhishu!\n",num);	
	}
	return 0;	
}

判断一个数是否为质数/素数——从普通判断算法到高效判断算法思路

定义：

约数只有1和本身的整数称为质数/素数。

1）直观判断法

最直观的方法，根据定义直接判断从2到n-1是否存在n的约数即可。

C++代码如下：

bool isPrime_1(int num)
{
    int tmp = num- 1;
    for(int i = 2;i <= tmp;i++)
        if(num % i == 0)
             return 0;
    return 1;
}

2）直观判断法改进

上述判断方法，明显存在效率极低的问题。

对于每个数n，其实并不需要从2判断到n-1。

一个数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)。

据此，上述代码中并不需要遍历到n-1，遍历到sqrt(n)即可，因为若sqrt(n)左侧找不到约数，那么右侧也一定找不到约数。

C++代码如下：

bool isPrime_2(int num)
{
     int tmp = sqrt(num);
     for(int i = 2;i <= tmp;i++)
         if(num %i == 0)
             return 0;
     return 1;
}

3）快速辨别法

方法（2）应该是最常见的判断算法了，时间复杂度O(sqrt(n))，速度上比方法（1）的O(n)快得多。

下面讲一下这种更快速的判断方法；
首先看一个关于质数分布的规律：大于等于5的质数一定和6的倍数相邻。例如5和7，11和13,17和19等等；
证明：令x≥1，将大于等于5的自然数表示如下：
······ 6x-1，6x，6x+1，6x+2，6x+3，6x+4，6x+5，6(x+1），6(x+1)+1 ······
6x+2，6x+3，6x+4，由于2(3x+1)，3(2x+1)，2(3x+2)，所以它们一定不是素数。再除去6x本身，显然，素数要出现只可能出现在6x的相邻两侧。注意：在6的倍数相邻两侧并不是一定就是质数。

此时判断质数可以6个为单元快进，即将方法（2）循环中i++步长加大为6，加快判断速度。

原因是，假如要判定的数为n，则n必定是6x-1或6x+1的形式。

对于循环中6i-1，6i，6i+1,  6i+2，6i+3，6i+4，

其中如果n能被 6i，6i+2，6i+4整除，则n至少得是一个偶数，但是6x-1或6x+1的形式明显是一个奇数，故不成立；

另外，如果n能被6i+3整除，则n至少能被3整除，但是6x能被3整除，故6x-1或6x+1（即n）不可能被3整除，故不成立。

综上，循环中只需要考虑6i-1和6i+1的情况，即循环的步长可以定为6，每次判断循环变量k和k+2的情况即可，理论上讲整体速度应该会是方法（2）的3倍。

c++代码如下：

bool isPrime_3( int num )
{
    //两个较小数另外处理
    if(num == 2||num == 3 )
        return 1;
    //不在6的倍数两侧的一定不是质数
    if(num % 6 != 1&&num % 6 != 5)
        return 0;
    int tmp = sqrt(num);
    //在6的倍数两侧的也可能不是质数
    for(int i = 5;i <= tmp;i += 6)
        if(num %i == 0||num % (i+ 2) == 0)
            return 0;
    //排除所有，剩余的是质数
    return 1;
}

算法性能测试：

编写测试代码，使用较多数据测试比较几种方法的判断效率，数据量40w，代码如下：

#include <iostream>
#include <string>
#include <ctime>
#include <vector>
using namespace std;
bool isPrime_1( int num );
bool isPrime_2( int num );
bool isPrime_3( int num );
int main()
{
                 int test_num = 400000;
                 int tstart,tstop; //分别记录起始和结束时间
                 //测试第一个判断质数函数
                 tstart=clock();
                 for(int i = 1;i <= test_num;i++)
                                 isPrime_1(i);
                 tstop=clock();
                 cout<<"方法(1)时间(ms):" <<tstop- tstart<<endl ;//ms为单位
                 //测试第二个判断质数函数
                 tstart=clock();
                 for(int i = 1;i <= test_num;i++)
                                 isPrime_2(i);
                 tstop=clock();
                 cout<<"方法(2)时间(ms):" <<tstop- tstart<<endl ;
                 //测试第三个判断质数函数
                 tstart=clock();
                 for(int i = 1;i <= test_num;i++)
                                 isPrime_3(i);
                 tstop=clock();
                 cout<<"方法(3)时间(ms):" <<tstop- tstart<<endl ;
                 cout<<endl;
                 system("pause");
                 return 0;
}

测试结果：

可以看出，判断到40w，效率上方法（1）明显要差得多，方法（2）和方法（3）在这种测试数量下时间相差2倍多

单独对比方法（2）和（3），数据量加到1000w，结果如下：

可以看出，方法（2）和方法（3）在这种测试数量下时间相差依然是2倍多，不过已经是很不错的提升。
对了，附上运行环境，CPU-i5-3210，内存4G，win7，vs2012。