用C语言实现求一个整数的全部因数

        首先我们来认识下因数的定义，整数a除以整数b（b≠0）的商正好是整数而没有余数，我们就说b是a的因数。例如6=2*3，那么6/2=3，6/3=2，就可以称2，3是6的因数。接下来我们进入正题，用c求因数。

逐步遍历法

        首先我们了解下原理，一个A（整数）的全部因数必定小于A，那么如果我们从1到A每个整数都除A，若A/n（1到A每个整数）=整数，那么n不就是A的因数了么。

例如6/1=6；6/2=3；6/3=2；6/4=1.5；6/5=1.2；6/6=1。那么1，2，3，6便是6的全部因数。

下面是代码

#include <stdio.h>

int main()
{
	int a = 0;
	int i = 0;
	scanf("%d", &a);
	for (i = 1;i <= a;i++)
	{
		if (a%i==0)     //可以整除与余数为0等价
			printf("%d\t", i);
	}
	return 0;
}

        当然这种算法比较容易理解，但程序运行效率低。

        如果我们仔细观察不难发现，如果A/n=m（m,n都是整数），m,n一定都为A的因数，例如6/2=3。2，3为6的因数。由此便引发我们下一种算法。

取根遍历

        同样我们先了解下他的内在原理，我们分为两种情况讨论。

(1)√A为小数

        我们取n，n>=1并且n<√A的整数.。逐步叠加1（1.2.3.4......），假设此时出现了A/n=m （m,n都为整数）的情况，那么m，n必定都为A的因数。此时我们在进一步思考。A=√A*√A，n为小于√A的整数，那么根据等式A=m*n，要想使他一直成立，m必定会大于√A。m,n成一一对应关系。换句话说是不是我们只需计算A/n（n>=1并且n<√A的整数）找出因数n，就可以对应找出在√A到A的因数m。这也是第二种算法的核心，只需第一钟算法一半的运算便可达到相同的结果。

（2）√A为整数

        与（1）相同的道理只不过此时√A为整数罢了，n取值范围变为n>=1并且n<=√A的整数。

下面是代码

#include <stdio.h>
#include <math.h>
int main()
{
	int a = 0;
	int i = 0;
	scanf("%d", &a);
	for (i = 1;i <= sqrt(a);i++)//sqrt()是math.h内置的函数，用于求根号
	{
		if (a % i == 0)
		{
			if (i != a / i)
				printf("%d %d ", i, a / i);
			else
				printf("%d", i);
		}
	}
	return 0;
}

        第二种算法实际上是对第一种算法的优化。与之有趣的还有一种现象，如果√A为整数，那么A的因数个数为奇，如果√A为小数，A的因数个数为偶，相信你一定可以看出其中的原理。接下来让我们介绍最后一种算法吧。

幂乘法

            同样我们先了解下他背后的数学原理。

A=(2^n1)*(3^n2)*(5^n3)*(7^n4)*质数……(n1，n2,n3,n4都为整数）

        A可以写成如下的形式，质数指因数只有1和他自身的数，A=(1^n1)*(2^n2)*(3^n3)*(4^n4)*(5^n5)*(6^n6)*(7^n7)*(8^n8)*(9^n9)*质数……,其中1，4，6，8，9，又可拆成2，3的组合故最后写成如下形式A=(2^n1)*(3^n2)*(5^n3)*(7^n4)*质数……。其中n都为整数。后续质数可以有无数个但为了程序的可运行只选了主要的几个质数。

        例如6=（2^1）*（3^1）,写成这样的形式，我们仔细想想，如果我们此时n1,n2取不大于1的整数（包括0），[（2^1）*（3^1）]  /  [（2^n1）*（3^n2）]=（2^（1-n1））*（3^（1-n2））

是不是必定为整数，可以正好的相除。由此我们便可以看出所谓6的因数实际上是n1，n2取不同值的组合罢了。例如6的因数1=（2^0）*（3^0），2=（2^1）*（3^0），3=（2^0）*（3^1），6=（2^1）*（3^1）。是不是恍然大悟！

        A=(2^n1)*(3^n2)*(5^n3)*(7^n4)*质数……面对较为大的数只需一个个取n的值即可，A的因数就是不同n的值带入的结果，切记n要不大于原来的指数。对于其他质数也同样如此.

      

        接下来代码如下

        

#include <stdio.h>
#include <math.h>
int main()
{
	int a = 0;
	double n1 = 0, n2 = 0, n3 = 0, n4 = 0 ;
	double i1 = 0, i2 = 0, i3 = 0, i4 = 0;//初始化变量
	int i5 = 0, i6 = 0;
	int zu[1000] = { 0 };
	scanf("%d", &a);

	while (a % 2 == 0)
	{
		a = a / 2;
		n1++;
	}
	while (a % 3 == 0)
	{
		a = a / 3;
		n2++;
	}
	while (a % 5 == 0)
	{
		a = a / 5;
		n3++;
	}
	while (a % 7 == 0)
	{
		a = a / 7;
		n4++;
	}//统计各数的指数,此时a不在是原来的a，而是除过n个2，3，5，7的a
	
	if (a == 1)
	{

		for (i1 = 0;i1 <= n1;i1++)
		{
			for (i2 = 0;i2 <= n2;i2++)
			{
				for (i3 = 0;i3 <= n3;i3++)
				{
					for (i4 = 0;i4 <= n4;i4++)
					{
						printf("%.0lf\t", pow(2, i1) * pow(3, i2) * pow(5, i3) * pow(7, i4));
					}
				}
			}//pow(a,b)是 <math.h>内置函数，要求a,b为double类型数

		}

	}
	else
	{
		for (i5 = 1;i5 <= sqrt(a);i5++)//sqrt()是math.h内置的函数，用于求根号
		{
			if (a % i5 == 0)
			{
				if (i5 != a / i5)
				{
					zu[i6] = i5;
					zu[i6 + 1] = a / i5;
					i6 = i6 + 2;
				}
				else
				{
					zu[i6] = i5;
					i6 = i6 + 1;
				}
			}
		}//运用了第二种方法。若a的全部因数
		for (i5 = 0;i5 < i6;i5++)
		{
			for (i1 = 0;i1 <= n1;i1++)
			{
				for (i2 = 0;i2 <= n2;i2++)
				{
					for (i3 = 0;i3 <= n3;i3++)
					{
						for (i4 = 0;i4 <= n4;i4++)
						{
							printf("%.0lf\t", pow(2, i1) * pow(3, i2) * pow(5, i3) * pow(7, i4)*zu[i5]);
						}
					}
				}//pow(a,b)是 <math.h>内置函数，要求a,b为double类型数

			}


		}

	}
	return 0;
}

        在上述代码中我们只求了质数2，3，5，7的指数，我们无法列出全部的质数，所以当我们求完2，3，5，7的指数后，我们求除过2，3，5，7的A的因数。实际上我们仔细想想，2^0,2^1……是不是就是2^n1的因数，为了程序可运行我们不可能列出全部质数，只能采用这种折中的方法。

        这种算法比较复杂，当求的数特别大时，效率最高，如果数不算太大用第二种便足以。

        如果要求一个数因数的个数，那么就等于（n1+1)*（n2+1)*（n3+1)*（n4+1)……也可以写成（n1+1)*（n2+1)*（n3+1)*（n4+1)*m，m为A/[（n1+1)*（n2+1)*（n3+1)*（n3+1) ]的因数个数。相信你看完上面的代码便可以理解。

        最后如果有错误欢迎在评论区指出，觉得不错的点点赞，喜欢的点点收藏与关注。