素数生成算法

最新推荐文章于 2024-03-05 20:09:57 发布
最新推荐文章于 2024-03-05 20:09:57 发布
阅读量1.6w 收藏 16
点赞数 5
分类专栏： Algorithm

1. 根据概念判断:

如果一个正整数只有两个因子, 1和p，则称p为素数.这是通常最先想到的判断方法：
代码: 
bool isPrime(int n) {     
if(n < 2) return false;   
   for(int i = 2; i < n; ++i)        
 if(n%i == 0) return false;      return true; }
时间复杂度O(n).

 2. 改进, 偶数都可以被2整除，去掉所有偶数

代码：
 
bool isPrime(int n) 
{     
 if(n < 2) return false;     
 if(n == 2) return true;     
 if(n%2 == 0) return false;     
 
 for(int i = 3; i < n; i += 2)         
  if(n%i == 0) return false;     
 return true; 
}
时间复杂度O(n/2), 速度提高一倍.

3. 进一步减少判断的范围

定理: 如果n不是素数, 则n有满足1<d<=sqrt(n)的一个因子d.
证明: 如果n不是素数, 则由定义n有一个因子d满足1<d<n.
如果d大于sqrt(n), 则n/d是满足1<n/d<=sqrt(n)的一个因子.

代码: 
bool isPrime(int n)
{
    if(n < 2) return false;
    if(n == 2) return true;
    if(n%2 == 0) return false;
    int foo = (int)sqrt(n);
    for(int i = 3; i <= foo; i += 2)
        if(n%i == 0) return false;
    return true;
}
时间复杂度O(sqrt(n)/2), 速度提高O((n-sqrt(n))/2).

4. 剔除因子中的重复判断.
例如: 11%3 != 0 可以确定 11%(3*i) != 0.

定理: 如果n不是素数, 则n有满足1<d<=sqrt(n)的一个"素数"因子d.
证明: I1. 如果n不是素数, 则n有满足1<d<=sqrt(n)的一个因子d.
I2. 如果d是素数, 则定理得证, 算法终止.
I3. 令n=d, 并转到步骤I1.

由于不可能无限分解n的因子, 因此上述证明的算法最终会停止.
代码: 
       
       

        
        // primes[i]是递增的素数序列: 2, 3, 5, 7, ... 
        
        
// 更准确地说primes[i]序列包含1->sqrt(n)范围内的所有素数  
        
        
bool isPrime(int primes[], int n) 
        
        
{     
        
        
 if(n < 2) return false;      
        
        
 for(int i = 0; primes[i]*primes[i] <= n; ++i)         
        
        
  if(n%primes[i] == 0) return false;      
        
        
 return true; 
        
        
}
假设n范围内的素数个数为PI(n), 则时间复杂度O(PI(sqrt(n))).

函数PI(x)满足素数定理: ln(x)-3/2 < x/PI(x) < ln(x)-1/2, 当x >= 67时.

因此O(PI(sqrt(n)))可以表示为O(sqrt(x)/(ln(sqrt(x))-3/2)),

O(sqrt(x)/(ln(sqrt(x))-3/2))也是这个算法的空间复杂度.
5. 构造素数序列primes[i]: 2, 3, 5, 7, ...

由4的算法我们知道, 在素数序列已经被构造的情况下, 判断n是否为素数效率很高;

但是, 在构造素数序列本身的时候, 是否也可是达到最好的效率呢?

事实上这是可以的! -- 我们在构造的时候完全可以利用已经被构造的素数序列!

假设我们已经我素数序列: p1, p2, .. pn

现在要判断pn+1是否是素数, 则需要(1, sqrt(pn+1)]范围内的所有素数序列,

而这个素数序列显然已经作为p1, p2, .. pn的一个子集被包含了!
代码: 
// 构造素数序列primes[]  
void makePrimes(int primes[], int num) 
{     
 int i, j, cnt;          
 primes[0] = 2;     
 primes[1] = 3;          
 for(i = 5, cnt = 2; cnt < num; i += 2)     
 {         
  int flag = true;          
  for(j = 1; primes[j]*primes[j] <= i; ++j)         
  {             
   if(i%primes[j] == 0)             
   {                 
    flag = false; 
    break;             
   }         
  }         
  if(flag) 
   primes[cnt++] = i;     
 } 
}
makePrimes的时间复杂度比较复杂, 而且它只有在初始化的时候才被调用一次.

在一定的应用范围内, 我们可以把近似认为makePrimes需要常数时间.

在后面的讨论中, 我们将探讨一种对计算机而言更好的makePrimes方法.

6. 更好地利用计算机资源...

当前的主流PC中, 一个整数的大小为2^32. 如果需要判断2^32大小的数是否为素数,

则可能需要测试[2, 2^16]范围内的所有素数(2^16 == sqrt(2^32)).

由4中提到的素数定理我们可以大概确定[2, 2^16]范围内的素数个数.

由于2^16/(ln(2^16)-1/2) = 6138, 2^16/(ln(2^16)-3/2) = 6834,

我们可以大概估计出[2, 2^16]范围内的素数个数6138 < PI(2^16) < 6834.

在对[2, 2^16]范围内的素数进行统计, 发现只有6542个素数:

p_6542: 65521, 65521^2 = 4293001441 < 2^32, (2^32 = 4294967296)
p_6543: 65537, 65537^2 = 4295098369 > 2^32, (2^32 = 4294967296)

在实际运算时unsigned long x = 4295098369;将发生溢出, 为131073.

在程序中, 我是采用double类型计算得到的结果.

分析到这里我们可以看到, 我们只需要缓冲6543个素数, 我们就可以采用4中的算法

高效率地判断[2, 2^32]如此庞大范围内的素数!

(原本的2^32大小的问题规模现在已经被减小到6543规模了!)

虽然用现在的计算机处理[2, 2^16]范围内的6542个素数已经没有一点问题,

虽然makePrimes只要被运行一次就可以, 但是我们还是考虑一下是否被改进的可能?!

我想学过java的人肯定想把makePrimes作为一个静态的初始化实现, 在C++中也可以

模拟java中静态的初始化的类似实现:

#define NELEMS(x) ((sizeof(x)) / (sizeof((x)[0])))

static int primes[6542+1];
static struct _Init { _Init(){makePrimes(primes, NELEMS(primes);} } _init;

如此, 就可以在程序启动的时候自动掉用makePrimes初始化素数序列.

但, 我现在的想法是: 为什么我们不能在编译的时候调用makePrimes函数呢?

完全可以!!! 代码如下:
代码: 
     
     

      
      // 这段代码可以由程序直接生成  
      
      
const static int primes[] =  {
      
      
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,101,103, 
      
      
107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211, 
      
      
223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331, 
      
      
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449, 
      
      
457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587, 
      
      
593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,
      
      
719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,
      
      
857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991, ... 65521, 65537 };
有点不可思议吧 , 原本makePrimes需要花费的时间复杂度现在真的变成O(1)了!

7. 二分法查找

现在我们缓存了前大约sqrt(2^32)/(ln(sqrt(2^32)-3/2))个素数列表, 在判断2^32级别的

素数时最多也只需要PI(sqrt(2^32))次判断(准确值是6543次), 但是否还有其他的方式判断呢?

当素数比较小的时候(不大于2^16), 是否可以直接从缓存的素数列表中直接查询得到呢?

答案是肯定的! 由于primes是一个有序的数列, 因此我们当素数小于2^16时, 我们可以直接

采用二分法从primes中查询得到(如果查询失败则不是素数).
代码: 
     
     

      
      // 缺少的代码请参考前边  
      
      
#include <stdlib.h>  
      
      
static bool cmp(const int *p, const int *q) 
      
      
{     
      
      
 return (*p) - (*q); 
      
      
}  
      
      
bool isPrime(int n) 
      
      
{     
      
      
 if(n < 2) return false;     
      
      
 if(n == 2) return true;     
      
      
 if(n%2 == 0) return false;      
      
      

      
      
 if(n >= 67 && n <= primes[NELEMS(primes)-1])     
      
      
 {         
      
      
  return NULL != bsearch(&n, primes, NELEMS(primes), sizeof(n), cmp);     
      
      
 }     
      
      
 else     
      
      
 {         
      
      
  for(int i = 1; primes[i]*primes[i] <= n; ++i)             
      
      
   if(n%primes[i] == 0) return false;         
      
      
  return true;     
      
      
 } 
      
      
}
时间复杂度:

if(n <= primes[NELEMS(primes)-1] && n >= 67): O(log2(NELEMS(primes))) < 13;
if(n > primes[NELEMS(primes)-1]): O(PI(sqrt(n))) <= NELEMS(primes).

8. 素数定理+2分法查找

在7中, 我们对小等于primes[NELEMS(primes)-1]的数采用2分法查找进行判断.

我们之前针对2^32缓冲的6453个素数需要判断的次数为13次(log2(1024*8) == 13).

对于小的素数而言(其实就是2^16范围只内的数), 13次的比较已经完全可以接受了.

不过根据素数定理: ln(x)-3/2 < x/PI(x) < ln(x)-1/2, 当x >= 67时, 我们依然

可以进一步缩小小于2^32情况的查找范围(现在是0到NELEMS(primes)-1范围查找).

我们需要解决问题是(n <= primes[NELEMS(primes)-1):

如果n为素数, 那么它在素数序列可能出现的范围在哪?

---- (n/(ln(n)-1/2), n/(ln(n)-3/2)), 即素数定理!

上面的代码修改如下:

代码: 
     
     

      
       bool isPrime(int n) 
      
      
{     
      
      
 if(n < 2) return false;     
      
      
 if(n == 2) return true;     
      
      
 if(n%2 == 0) return false;      
      
      
 
      
      
 int hi = (int)ceil(n/(ln(n)-3/2));      
      
      
 if(n >= 67 && hi < NELEMS(primes))     
      
      
 {         
      
      
  int lo = (int)floor(n/(ln(n)-1/2));          
      
      
  return NULL != bsearch(&n, primes+lo, hi-lo, sizeof(n), cmp);     
      
      
 }     
      
      
 else     
      
      
 {
      
      
          for(int i = 1; primes[i]*primes[i] <= n; ++i)             
      
      
   if(n%primes[i] == 0) return false;         
      
      
  return true;     
      
      
 } 
      
      
}
时间复杂度:

if(n <= primes[NELEMS(primes)-1] && n >= 67): O(log2(hi-lo))) < ???;
if(n > primes[NELEMS(primes)-1]): O(PI(sqrt(n))) <= NELEMS(primes).


9. 打包成素数库(给出全部的代码)

到目前为止, 我已经给出了我所知道所有改进的方法(如果有人有更好的算法感谢告诉我).

这里需要强调的一点是, 这里讨论的素数求法是针对0-2^32范围的数而言, 至于像寻找

成百上千位大小的数不在此讨论范围, 那应该算是纯数学的内容了.

代码保存在2个文件: prime.h, prime.cpp.
代码: 
       
       

        
        // file: prime.h  
        
        
#ifndef PRIME_H_2006_10_27_ 
        
        
#define PRIME_H_2006_10_27_  
        
        
extern int  Prime_max(void);        // 素数序列的大小 
        
        
extern int  Prime_get (int i);        // 返回第i个素数, 0 <= i < Prime_max  
        
        
extern bool Prime_test(int n);        // 测试是否是素数, 1 <= n < INT_MAX  
        
        
#endif  
        
        
///  
        
        
// file: prime.cpp  
        
        
#include <assert.h> 
        
        
#include <limits.h> 
        
        
#include <math.h> 
        
        
#include <stdlib.h>  
        
        
#include "prime.h"  
        
        
// 计算数组的元素个数  
        
        
#define NELEMS(x) ((sizeof(x)) / (sizeof((x)[0])))  // 素数序列, 至少保存前6543个素数!  
        
        
static const int primes[] =  { 
        
        
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,101,103, 107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211, 223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331, 337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449, 457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587, 593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709, 719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853, 857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991, ... 65521, 65537 };  
        
        

        
        
// bsearch的比较函数  
        
        
static int cmp(const void *p, const void *q) 
        
        
{     
        
        
 return (*(int*)p) - (*(int*)q); 
        
        
}  
        
        

        
        
// 缓冲的素数个数  
        
        
int Prime_max() 
        
        
{     
        
        
 return NELEMS(primes); 
        
        
}  
        
        

        
        
// 返回第i个素数  
        
        
int Prime_get(int i) 
        
        
{     
        
        
 assert(i >= 0 && i < NELEMS(primes));     
        
        
 return primes[i]; 
        
        
}
        
        

        
        
// 测试n是否是素数  
        
        
bool Prime_test(int n) 
        
        
{     
        
        
 assert(n > 0);      
        
        
 if(n < 2) return false;     
        
        
 if(n == 2) return true;     
        
        
 if(!(n&1)) return false;      
        
        
 // 如果n为素数, 则在序列hi位置之前      
        
        
 int lo, hi = (int)ceil(n/(log(n)-3/2.0));      
        
        
 if(hi < NELEMS(primes))     
        
        
 {       // 确定2分法查找的范围         
        
        
  // 只有n >= 67是才满足素数定理          
        
        
  if(n >= 67) 
        
        
   lo = (int)floor(n/(log(n)-1/2.0));         
        
        
  else 
        
        
  {
        
        
    lo = 0; hi = 19; 
        
        
  }          
        
        
  // 查找成功则为素数          
        
        
  return NULL != bsearch(&n, primes+lo, hi-lo, sizeof(n), cmp);     
        
        
 }     
        
        
 else     
        
        
 {         // 不在保存的素数序列范围之内的情况          
        
        
  for(int i = 1; primes[i]*primes[i] <= n; ++i)             
        
        
   if(n%primes[i] == 0) return false;          
        
        
  return true;     
        
        
 } 
        
        
}
10. 回顾, 以及推广

到这里, 关于素数的讨论基本告一段落. 回顾我们之前的求解过程, 我们会发现

如果缺少数学的基本知识会很难设计好的算法; 但是如果一味地只考虑数学原理,

而忽律了计算机的本质特征, 也会有同样的问题.

一个很常见的例子就是求Fibonacci数列. 当然方法很多, 但是在目前的计算机中

都没有实现的必要!

因为Fibonacci数列本身是指数增长的, 32位的有符号整数所能表示的位置只有前46个:

代码: 
static const int Fibonacci[] =  {     
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,     
2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,    
317811,514229,832040,1346269,2178309,3524578,5702887,9227465,    
14930352,24157817,39088169,63245986,102334155,165580141,267914296,     
433494437,701408733,1134903170,1836311903,-1323752223 };
因此, 我只需要把前46个Fibonacci数保存到数组中就可以搞定了!

比如: F(int i) = {return Fibonacci[i];} 非常简单, 效率也非常好.
wangran51
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
素数判定算法
Frost_Bite的博客
04-08 1万+
1、取余算法 对一个大于1的自然数 n 依次判断 2 → √n 能否整除 n，如果发现一个数能整除 n，那么 n 不是素数，否则是。 C++代码如下： bool isPrime(int n) { if (n <= 1) return false;i for (int i = 2; i * i < n; i++) if (n % ...
求素数的高效算法_生成素数的高效算法
cunchi8090的博客
07-20 1040
求素数的高效算法 Prime numbers are natural numbers greater than 1 that have only two divisors (the number itself and 1). By “divisible” we mean dividend % divisor = 0 (% indicates MODULAR....
C语言学习1：素数的判定与素数表的生成
Huih_cannot_fly的博客
02-15 516
C语言学习1：素数的判定与素数表的生成 摘要：本文主要探究素数的判别和素数表的生成，为初学时写下作为学习笔记。 一、素数的判定 1.平方根以下遍历法 基本思想： 由数学证明可知，若要判定一个数是否为素数，只需将其除以 [ 2 , sqrt(x) ) , 其中x是这个数本身。另外为了优化计算，可以先判定是否为非2整数。基于这个思想，我们可以给出以下代码。 int isPrime ( int x ) ...
100~200以内的素数
05-06
//100~200以内的素数 #include <stdio.h> main() { int i,j; for(i=101;i<200;i++) { for(j=2;j<i;j++) { if(i%j==0) { break; } } if(i==j) printf("%d是素数\n",i); } }
RSA加密、解密、签名、验签的原理及方法
最新发布
Innocence_0的博客
03-05 1525
一、RSA加密简介RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。二、RSA加密、签名区别加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。
超完整素数算法总结归纳
m0_61567378的博客
12-06 3105
目录 素数的判定 Eratosthenes筛选（素数筛选） 因子数与因子和 完美数 n的第k个因子 分拆质数和 分解质因数 最接近的因数 丑数 素数的判定 Eratosthenes筛选（素数筛选） 因子数与因子和 完美数 n的第k个因子 分拆质数和 分解质因数 四因数 最接近的因数 丑数 素数的判定 素数的概念是只可以被1和他本身可以整除 所以我们可以使用试除法，如一个数为n （用2-n-1）对n进行试除,但是这样的话时间复杂度是O(N) #...
浅析求素数算法(部分看不懂，保存以后来看)
yehenhei的专栏
11-29 938
浅析求素数算法 时间: 2006-10-27 注意: 如果没有特殊说明, 以下讨论的都是针对n为素数时的时间复杂度 1. 根据概念判断: 如果一个正整数只有两个因子, 1和p，则称p为素数. 代码: bool isPrime(int n) { if(n < 2) return false; for(int i = 2; i
demytko素数生成算法(完善版)
01-15
demytko素数生成算法输入小素数生成大素数,如2,经10次循环,得到大素数411043979,时间为25秒
rsa素数生成及加密算法
12-24
可以随机生成素数，并生成公钥私钥，对明文进行加密。
随机生成大素数
06-05
RSA算法中随机生成大素数的代码，仅供学习用。
密码学大素数生成
02-25
针对密码学中RSA加密算法，因为其首先需要生成大素数
基于生成孪生素数算法的小型评测模型研究.pdf
09-09
基于生成孪生素数算法的小型评测模型研究、
有关素数的各种算法
qq_43710979的博客
03-09 939
素数&amp;amp;&amp;amp;算法 素数是个神奇的东西，在数论里经常用到，有很多奇奇怪怪的性质，但是判断一个数是不是素数就是个很麻烦的事情。 1.定义 素数就是质数，两个名词指的是同一种数。 素数的定义是：素数为在大于1的自然数中，除了1和它本身以外不再有其他因数。 和素数相反的就是合数，当然合数也是大于1的， 其中注意两点： 素数一定大于1，也就是说1不是素数 偶数只有2是质数，其余都是...
素数求法的四种方法（逐次优化）
zjybp的博客
03-04 3323
/* 思路： 素数：即质数，除了1和自己之外，再没有其他的约数，则该数据为素数，具体方式如下 */ //方法一：试除法 int main() { int i = 0; int count = 0; // 外层循环用来获取100~200之间的所有数据，100肯定不是素数，因此i从101开始 for(i=101; i<=200; i++) { //判断i是否为素数：用[2, i)之间的每个数据去被i除，只要有一个可以被整除，则不是素数 int j = 0; fo
素数运算——生成素数的方法
ミ渴望ヽ不可及ゞ的博客
10-12 1820
素数又称质数，指的是在大于1的自然数中除了1和自身外无法被其他自然数整除的数。比1大但不是素数的自然数称为合数。1和0既非素数也非合数。合数可以表示为若干个素数的积。 方法一： 计算整数区间[2,n]中所有素数的最为简便的筛法——埃氏筛法。 设u[]为筛子，初始区间中的所有数在筛子u[]中。按递增顺序搜索u[]中的最小数，将其倍数从u[]中筛去，最终留下的数即为素数。 int i,j,k; f...
素数求解（5种方法）
qq_74732628的博客
04-23 6755
素数求解多种方法
求素数的三大算法 —— Java 篇
weixin_61635597的博客
04-07 6317
求素数的三大算法 —— Java 篇 素数又叫质数（prime number），有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。 算法一 ：暴力遍历 思路： 素数我们运用两个循环的遍历的方式，首先根据素数的定义：质数定义为在大于1的自然数中，除了1和它本身以外不再被其数整除了。因为任何数都可以被 1 整除的，所以我们的第一个for( )循环语句的初始值从 2 开始进行，到你所需的范围。 我们的第二个for（）循环语句，的判断条件是：从上个for（）循环语句的 变化值开始，
经典加密算法的实现与破解&大素数生成算法
iO快到碗里来
10-16 2482
经典加密算法的实现与破解 一、实现凯撒加密 在密码学中，恺撒密码（英语：Caesar cipher），或称恺撒加密、恺撒变换、变换加密，是一种最简单且最广为人知的加密技术。它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。这个加密方法是以罗马共和时期恺撒的名字命名的，当年恺撒曾用此方法与其将军们进行联系。 ...
实验三：实现一个大素数生成算法
05-31
生成大素数是一个重要的加密技术中的一部分。下面介绍一种大素数生成算法: 1. 随机生成一个大奇数 $n$。 2. 判断 $n$ 是否为素数，可以通过 Miller-Rabin 素性检验算法来进行判断。该算法的基本思想是：如果 $n$ 是一个合数，则在模 $n$ 意义下，至少有一半的数都不是 $n$ 的伪素数。重复进行多次 Miller-Rabin 检验可以大大提高素数检测的可靠性。如果 $n$ 经过多次检验均为素数，则认为 $n$ 是一个大素数。 3. 如果 $n$ 不是素数，则将 $n$ 加上 $2$，重复步骤二。 4. 如果 $n$ 是素数，则返回 $n$。 需要注意的是，该算法并不能保证一定能够生成出一个大素数，但是通过多次运行该算法，可以生成出足够大的素数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值