整数n分解成素数乘积c语言,用C语言和汇编语言实现将1个整数分解成几个素数的乘积...

任何1个大于2的整数都可以分解成几个素数的乘积。将1个整数分解成几个素数的乘积是个热门话题。

经常有人问到。本文试图用C语言和32位X86汇编语言给出一个比较好的实现。希望对c语言学习者和

汇编语言学习者带来帮助。

问题的提出：将一个整数分解素因数

根据算术基本定理，任何大于2的正整数都可以表示为素数的乘积，如果不考虑这些素数出现的次序，其

表示方式为唯一的。本题目的要求是输入一个正整数，将这个正整数显示为几个素数乘积的形式，如

如

1=1

2=2

3=3

4=2*2

5=5

6=2*3

7=7

...

60=2*2*3*5

算法：

对于合数n，它总可表示为两个数的乘积，如n=a*b,令a<=b,容易证明a <= sqrt(n),这里sqrt(n)表示n的

平方根，下同。这说明了，用i =2 到 sqrt(n)之间的数逐一试除，如果所有的i都不是n的因数，则n一定

是一个素数。如果在试除过程中,某个i能够整数n，则将i存入因子表，n/i => n,直到 i*i大于n为止。

在试除过程中，若p和q都是n的因子，p是素数，q大于p，q是p的倍数，如果p能够整除n，则n = n / p,

这样，最终n就不再是p的倍数，故n也不会是q的倍数，故在计算n = n / p这一过程，p一定是一个素数，

这种方法得到的所有因子都是素因子。

在所有的试除方法中，最少的试除步骤是用2到sqrt(n)之间的所有素数去试除。但这个算法需要预先算出

sqrt(n)之间的所有素数。这是最快的算法，但我们这里不打算搞得这么复杂，我们这里的算法是用2和所有2

以上的奇数去试出。因为如果一个数是4，6，8的倍数，那么他一定是2的倍数，当被2除后，就不需要试再试

除4,6,8了。

下面给出一个C语言的实现

#include #include typedef unsigned long DWORD;

//函数decomp_integer对n分解素因数，分解后的素数存入facArr数组，并返回因子的个数

int decomp_integer( DWORD n, DWORD facArr[])

{

DWORD fac; //n的可能的一个因子

int count;

if (n<4) //4以内的数，不需要分解

{

facArr[0]=n; return 1;

}

count=0;

//下面的while循环为2试出n，直到2不是n的因子为止

while ( (n & 1)==0) // 这里判断偶数用 (n &1)==0，这比(n % 2)==0更快

{

facArr[count++]=2; n/=2;

}

fac=3; //用3到sqrt(n)之间的奇数试除

while (fac*fac<=n) // fac*fac <= n

{

while (n % fac==0)

{

facArr[count++]=fac;

n /= fac;

}

fac+=2;

}

if (n==1)

return count;

facArr[count++]=n;

return count;

}

int main(int argc, char* argv[])

{

DWORD n,facArray[32];

int i,count;

printf("Please input unsigned integer:");

scanf("%u",&n);

count=decomp_integer(n,facArray);

printf("%u=%u",n,facArray[0]);

for (i=1;i

汇编语言可能是最麻烦的语言，在实践中，除非必要，好少有人用汇编语言写程序。这主要是因为

1.同样的题目，用汇编语言编程需要的代码量较大，费时费力

2.汇编语言的可读性很差，日后维护的成本也大。

许多有经验的工程师对汇编语言写程序都很头疼，对许多初学这说，更是一件难以完成的任务。

初学者常犯的错误是，一上来就有汇编写程序，不管有没有理清头绪，这样造成的结果就是，程序改

了又改，但总是不对，好容易改对了，但程序的风格很差，代码冗长，逻辑混乱，可读性很差。其实，

用任何语言写成都需要设计，程序应该具有模块化，条理清晰，风格一致。汇编语言是最接近机器的

语言，编写汇编程序，非常有利用理解计算机的工作原理。

个人觉得，对于一个逻辑比较复杂的汇编程序的设计，不妨采用高级语言为原型，用高级语言编译运

行通过了，说明你也就对这个题目理解了，然后，看看你的程序，哪里可以简化，哪里可以重构使其

更优雅。最后可将你用高级语言写的程序翻译成汇编语言，这里的翻译不是简单的翻译，汇编语言有

汇编语言的特点，他具有更大的灵活性，开发者应该总是用最适当的方式来实现它。

下面是这个题目的汇编版本，使用masm32编写。关于输入输出部分，使用的几个Windows API函数，

这里说明如下：

程序使用ReadFile从控制台输入数据，使用WriteConsole输出运算结果到控制台。字符串到数的转化

子程序是自己写的。见myAtoi。而数到字符串的转化调用的则是Windows API函数wsprintf。此外，程

序还用到GetStdHandle和ExitProcess，感兴趣的同学，可以查MSDN来得到更多的信息。

在C语言版，外循环的判断语句"while (fac*fac<=n)"使用了乘法，而汇编语言班则使用了性能更好的lea

指令，见下

mov edx,s_fac

mov eax,fac

lea edx,[edx+eax*4+4] ; (fac+2)*(fac+2)=s_fac * 4*fac+4

mov s_fac,edx

add fac,2            ; fac +=2

其基本原理为，若s_fac是fac的平方，则在求(fac+2)^2时，使用了数学公式(fac+2)^2= fac^2 + 4*fac +4,

这里的^表示乘方，程序中，fac和s_fac分别表示当前因子和当前因子的平方，然后当前因子加2，同时需要

更新s_fac,在上面的代码中，先计算(fac+2)^2,(fac+2)=fac^2 + 4*fac +4=s_fac+ 4*fac +4,然后计算fac+2.

lea指令支持*4,*8这样的形式，故这里使用lea指令而没有时候性能很慢的乘法指令。

下面给出汇编语言版的代码，可借助c版的程序来理解汇编版，同时请体会汇编语言和c语言在处理逻辑方面的

的不同，特别是分支和循环语句。

; 如何编译链接该程序

; 本程序需使用masm32来编译，若你的masm32安装在c盘，请设置如下环境变量

; set include=c:\masm32\include

; set lib=c:\masm32\lib

; set PATH=c:\masm32\bin;%PATH%

; 若本程序名为decomp.asm,则运行如下命令编译和链接和运行

; ml /c /coff decomp.asm

; link /subsystem:console decomp.obj

; decomp.exe

.386

.model flat,stdcall ; 32 bit memory model

option casemap :none ; case sensitive

include windows.inc

include user32.inc

includelib user32.lib

include kernel32.inc

includelib kernel32.lib

.data

facTab dd 32 dup(?) ;number的所有素因子

facCount dd ? ;number的所有素因子的个数

number dd ? ;被分解的数

fac dd ? ;number的当前因子

s_fac dd ? ;number的平方

tLen dd ? ;临时变量，仅在调用Windows API函数是用

hInput dd ? ;标准输入设备句柄

hOutput dd ? ;标准输出设备句柄

inBuffer db 32 dup(?) ;输入缓冲区

outBuffer db 128 dup(?) ;输出缓冲区

.const

szFmtIn db '%u',0

szFmtOut1 db 'Please input an unsigned integer:'

szFmtOut2 db '%u=%u',0

szFmtOut4 db '*%u',0

.code

;use global varible, don't pass any in parameter in stack

dcomp proc far uses esi

mov esi,number ;esi is copy of n

cmp esi,4

jae case_02

case_01:

mov facTab[0],eax

mov ecx,1

jmp this_exit

case_02:

xor ecx,ecx ;ecx: copy of count

jmp loop_02_cmp

loop_02:

mov facTab[ecx*4], 2

inc ecx ;count++

shr esi,1 ;esi is copy of n,n /=2

loop_02_cmp:

mov edx,esi

and edx, 1

jz loop_02 ; n % 2==0

mov fac,3

mov s_fac, 9

jmp loop03_outer_cmp

loop03_outer:

jmp loop03_inner_cmp

loop03_inner:

mov edx, fac

mov facTab[ecx*4],edx ;fac[count++]=fac

inc ecx ;count++

xor edx,edx

mov eax,esi

div fac

mov esi,eax

loop03_inner_cmp:

xor edx,edx

mov eax,esi

div fac

or edx,edx

jz loop03_inner

mov edx,s_fac

mov eax,fac

lea edx,[edx+eax*4+4] ; (fac+2)*(fac+2)=s_fac * 4*fac+4

mov s_fac,edx

add fac,2 ; fac +=2

loop03_outer_cmp:

mov eax,s_fac

cmp eax,esi

jbe loop03_outer

cmp esi,1 ;

jz this_exit ; n ==1

mov facTab[ecx*4],esi

inc ecx

mov eax,ecx

this_exit:

mov eax,ecx ;返回素因子数

ret

dcomp endp

; convert from a string to a integer

myAtoi proc far C uses ebx esi, var_String

mov esi,var_String ;in parameter => esi

mov ebx,10

xor eax,eax

xor ecx,ecx

loop_read_char:

mov cl,byte ptr [esi] ; get a char from in_buff

inc esi

sub cl,'0'

cmp cl,9

ja input_exit ;if the char '9', then jump out loop

mul ebx

add eax,ecx

jmp loop_read_char

input_exit:

ret

myAtoi endp

; use global varible, don't pass parameter in stack

; number: in parameter

; facTab: in paramter

; facCount: factor count

; hInstance: input device handle

output_fac proc far C uses ebx edi

lea edi, outBuffer

mov eax,facTab[0]

invoke wsprintf, edi, addr szFmtOut2,number,eax

add edi, eax

mov ebx,1

jmp next_cmp

convert_loop:

mov eax,facTab[ebx*4]

invoke wsprintf,edi,addr szFmtOut4,eax

add edi, eax ;edi the write pointer in next ; 下次输出时的地址送edi

inc ebx

next_cmp:

cmp ebx,facCount

jb convert_loop

print:

lea eax, outBuffer

sub edi, eax ;计算输出的字符串的长度，存入edi

invoke WriteConsole,hOutput,addr outBuffer,edi,addr tLen,0 ;在控制台输出

ret

output_fac endp

main proc far

invoke GetStdHandle,STD_OUTPUT_HANDLE ; 获取控制台输出设备的句柄

mov hOutput,eax

invoke WriteConsole,hOutput,addr szFmtOut1,sizeof szFmtOut1,addr tLen,0

invoke GetStdHandle,STD_INPUT_HANDLE ; 获取控制台输入设备的句柄

mov hInput, eax

invoke ReadFile,hInput,addr inBuffer,sizeof inBuffer,ADDR tLen,NULL

lea eax, inBuffer

invoke myAtoi,eax ;转化字符串为一个数

mov number, eax ;将这个数存入number

invoke dcomp ;调用因子分解子程序，,各个因子存入facTab

mov facCount,eax ;分解后的因子个数存入facCount

invoke output_fac ;调用output_fac打印number的分解式

xor eax, eax

invoke ExitProcess,eax ;退出进程

ret

main endp

end main

liangbch@263.net, 转载请注明出处。