浅析求解质数问题的一些方法

质数问题是算法中常见的和入门的问题,今天姑且用 "打印100以内所有质数" 这个问题,浅析一下求质数问题中的一些基础优化.

质数的定义

质数(prime number)又称质数，有无限个。

质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。

求解思路

根据质数的定义,我们可以用从2到这个数之间的数和这个数做除法,如果可以所有的数和这个数都不能整除,则说明这个数是质数,也就是试除法.

试除法求解质数1.0

根据我们的思路,可以写出一段简单的代码来求解质数.

x = 100 #给求质数限定的范围,根据上题设定为100,可以修改为更大

for i in range(2,x): #质数必定大于1,i从2开始,依次寻找到x,判断是否是我们需要的质数

for j in range(2,i):

if i % j == 0:

break #从2到j,如果存在一个数能被i整除,说明i一定不是质数,则终止这一次循环,用下一个i的值继续计算.

else:

print(i)

#如果遍历了j都没有出现能被i整除的情况,则说明这个数是质数,输出这个时候i的值

试除法求质数1.0总结

根据提出的求解质数的思路,我们提出了试除法1.0,但是这是根据思路得出的最直接最粗浅的写法,显然还有更多优化提升效率的空间.

我们在这里使用的是试除法求质数,用一个数依次和从2开始的比他小的数做除法运算,既然是除法运算,那么根据除法运算的特点,我们是否可以做一些优化呢?

在1.0中,我们提出了这样的代码

x = 100

for i in range(2,x):

for j in range(2,i):

if i % j == 0:

break

else:

print(i)

我们在做除法运算的时候,是从2一直除到i的,但是事实上,一个数,在除过他的1/2之后,直到除到他本身,都不会得到一个整数.

例如,给一个数1000,除以500,整除,得到商为2.然后从501开始,一直到999,1000除以这些数都不能整除.

所以,如果我们将j的范围,从(2,i)缩小到(2,i//2),从而减小试除的范围,提高效率.

试除法求质数2.0

x = 100

for i in range(2,x):

for j in range(2,i//2+1):#i为奇数时,可能会遗漏部分数字,故+1

if i % j == 0 :

break

else:

print(i)

试除法求质数2.0总结

2.0相较于1.0,效率是有提升的,但是我们是不是可以沿着这条思路继续优化呢.

由质数的性质有,对正整数n，如果用2到根号n之间的所有整数去除，均无法整除，则n为质数。

所以我们可以继续优化j的取值范围.

试除法3.0

x = 100

for i in range(2,x):

for j in range(2,int(i**0.5)+1):#i为奇数时,可能会遗漏部分数字,故+1

if i % j == 0 :

break

else:

print(i)

试除法求质数3.0总结

相对于2.0版本,当求取的质数的范围越大,3.0版本提升效率越明显.

在对于j的取值范围的功课,就暂时做到这里,那么i的取值是否可以再优化一下呢?

很明显,2以上的所有偶数,都有2这个约数,不可能为质数的,那么在i的取值上,通过调整step的方法排除掉偶数,可以得出试除法的4.0.

试除法求质数4.0

print(2) #先将2打印

for i in range(3,100,2): #每一个i的值都是奇数

for j in range(2,int(i**0.5)+1):

if i % j == 0:

break

else:

print(i)

试除法求质数4.0总结

通过这一步的优化,把i取值中的偶数全部去掉,进一步加快了效率.在jupyter中跑这段代码,求1,000,000(一百万)以内的质数,结果和1.0版本结果一样,演算成功.

既然i的取值区间可以这样优化,那么j的取值是不是也可以用类似思路思索一下呢?

我们在判断 if i % j == 0 时,i通过我们上一步的优化,已经全部变成奇数.显然,奇数的约数不可能为偶数,那么,同样的,对于j的取值空间,我们可以通过去除偶数的方法,进一步加快代码运行的效率.

试除法求质数5.0

print(2) #先将2打印

for i in range(3,100,2): #每一个i的值都是奇数

for j in range(3,int(i**0.5)+1,2):#每一个j的值都是奇数

if i % j == 0:

break

else:

print(i)

试除法求质数5.0总结

首先,回顾一下整段代码的逻辑有无谬误,然后通过计算1,000,000(一百万)内质数的个数,演算成功.

5.0版本和1.0版本相比,通过多次的优化,运行效率得到了大大的提升,我想这也是我们不断优化的意义所在.

最后贴两段代码,第一段是,用一个列表盛放已经求出来的素数,我们只需要用数去除这个列表里的素数就行了,而不是所有的奇数.

n = 100000 #我们求素数的范围,这里限定的是在100,000以内

prime_num = [2]

count = 1 #加一个计数器,方便检验代码运行结果是否正确

for x in range(3,n,2):

flag = True

edge = int(x**0.5)

"""

假如x除到的i已经大于edge,后面的数必然不能让x整除,

可以直接结束这段计算,减少计算量.

假如把这一段加入下面的循环之中的话,每一次的循环都要计算

一次int(x**0.5),效率太低

"""

for i in prime_num: ```

if x % i == 0:

flag = False

break

"""

假如进入这个if中,说明X为合数,flag

变为False,无法满足下面if flag的判断

"""

if i > edge:

break

if flag:

prime_num.append(x)

count += 1

print(prime_num)

在数论界有一个叫做孪生素数的猜想,虽然并没有被证明,但是穷举法也不能对该猜想证伪,在我们用穷尽求素数的时候,可以利用孪生素数的一些性质,加快代码运行的效率.

下面这一段代码,在上面这一段的基础上,加上了一些孪生素数的性质.

大于3的素数只在6的倍数周围出现.

这样,我们对X的取值就可以缩小到5,7(6-1,6+1),11,13(62-1,62+1).......等等等等的6n-1,6n+1了

x = 7 # first_num = 7

step = 4

n = 100000 # 素数的最大取值区间为100,000内

count = 3

prime_num = [2,3,5]

while x < n:

if x % 5 != 0:

flag = True

edge = int(x**0.5)

for i in prime_num:

if x % i == 0:

flag = False

break

if i > edge:

flag = True

break

if flag:

prime_num.append(x)

count += 1

x += step

step = 4 if step == 2 else 2

print(prime_num)

print(count)