计算一定范围内素数个数的算法

问题概述

问题：给定一个大整数N，计算开区间（1，N）的素数有多少？

• 算法1：根据素数性质，a不能整除小于等于根号a的所有整数，则必为素数，从1到N遍历找出所有素数。
• 算法2：素数筛选法，先剔除2的倍数，再剔除剩余的数中第一个数的倍数，直到剩余的数中第一个数大于根号N，此时剩下的数必全部为素数。

算法实现

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>

#undef  TRUE
#define TRUE    1
#undef  FALSE
#define FALSE   0

typedef int BOOL32;

// a不能整除小于等于根号a的所有整数，则必为素数
void ChoosePrimeNumber_Slow(int dwTestSize)
{
	BOOL32* pbNumber = new BOOL32[dwTestSize];
	if (NULL == pbNumber)
	{
		printf("[ChoosePrimeNumber_Slow] New Error!\n");
		return;
	}
	memset(pbNumber, 0, dwTestSize*sizeof(int));

	int dwIndex, dwLoop = 0;
	*(pbNumber+2) = TRUE;
	for(dwIndex=3; dwIndex<dwTestSize; dwIndex++)
	{ 
		for(dwLoop=2; dwLoop<= dwIndex; dwLoop++)
		{
			if(dwIndex%dwLoop==0) 
				break;

			if (dwLoop > (int)sqrt((double)dwIndex))
			{
				*(pbNumber+dwIndex) = TRUE;
				break;
			}
		}
	}	
	// 计算素数个数
	int dwNum = 0;
	for(dwIndex=2; dwIndex<dwTestSize; dwIndex++) 
	{
		if(*(pbNumber+dwIndex))
			dwNum++;
	}
	printf("less than %d, there are %d prime number!\n", dwTestSize, dwNum);

	delete []pbNumber;
	return;
}

// 素数筛选法
void ChoosePrimeNumber_Fast(int dwTestSize)
{
	BOOL32* pbNumber = new BOOL32[dwTestSize];
//	BOOL32* pbNumber = (BOOL32*) malloc(sizeof(BOOL32)*dwTestSize);
	if (NULL == pbNumber)
	{
		printf("[ChoosePrimeNumber_Fast] New Error\n");
		return;
	}	
	memset(pbNumber, 0, dwTestSize*sizeof(int));

	int dwIndex, dwLoop = 0;
	*(pbNumber+2) = TRUE;
	for(dwIndex=3; dwIndex<dwTestSize; dwIndex++)
	{
		if(0 != dwIndex%2) 
			*(pbNumber+dwIndex)=TRUE;
		else
			*(pbNumber+dwIndex)=FALSE;
	}
		
	for(dwIndex=3; dwIndex<=(int)sqrt((double)dwTestSize); dwIndex++)
	{
		if(*(pbNumber + dwIndex))
		{
			for(dwLoop=dwIndex+dwIndex; dwLoop<dwTestSize; dwLoop+=dwIndex) 
				*(pbNumber+dwLoop)=FALSE;
		}
	}
	// 计算素数个数
	int dwNum = 0;
	for(dwIndex=2; dwIndex<dwTestSize; dwIndex++)
	{
		if( *(pbNumber+dwIndex))
			dwNum++;
	}	
	printf("less than %d, there are %d prime number!\n", dwTestSize, dwNum);

	delete []pbNumber;
//	free(pbNumber);
	return;
}

///////////////////////////
int main()
{
	clock_t cBegin, cTime = 0;

	int dwTestNum = 10000;
	for (int dwloop = 0; dwloop<5; dwloop++)
	{
		cBegin = clock();
		ChoosePrimeNumber_Slow(dwTestNum);
		cTime = clock() - cBegin;

#ifndef  WIN32
		cTime=cTime/1000;
#endif
		printf("[%d] Method ChoosePrimeNumber_Slow spend %d ms.\n\n", dwloop, cTime);
		
		cBegin = clock();
		ChoosePrimeNumber_Fast(dwTestNum);
		cTime = clock() - cBegin;
		
#ifndef  WIN32
		cTime=cTime/1000;
#endif
		printf("[%d] Method ChoosePrimeNumber_Fast spend %d ms.\n\n", dwloop, cTime);

		dwTestNum = dwTestNum*10;
	}

	return 0;
}

运行结果

• CPU：Intel Core i3 2120
• RAM：2G

less than 10000, there are 1229 prime number!
[0] Method ChoosePrimeNumber_Slow spend 2 ms.

less than 10000, there are 1229 prime number!
[0] Method ChoosePrimeNumber_Fast spend 0 ms.

less than 100000, there are 9592 prime number!
[1] Method ChoosePrimeNumber_Slow spend 41 ms.

less than 100000, there are 9592 prime number!
[1] Method ChoosePrimeNumber_Fast spend 1 ms.

less than 1000000, there are 78498 prime number!
[2] Method ChoosePrimeNumber_Slow spend 973 ms.

less than 1000000, there are 78498 prime number!
[2] Method ChoosePrimeNumber_Fast spend 32 ms.

less than 10000000, there are 664579 prime number!
[3] Method ChoosePrimeNumber_Slow spend 23846 ms.

less than 10000000, there are 664579 prime number!
[3] Method ChoosePrimeNumber_Fast spend 398 ms.

less than 100000000, there are 5761455 prime number!
[4] Method ChoosePrimeNumber_Slow spend 643918 ms.

less than 100000000, there are 5761455 prime number!
[4] Method ChoosePrimeNumber_Fast spend 4695 ms.

Press any key to continue

算法分析

从运行结果显而易见，算法2效率要远远高于算法1。