题目：将一个正整数的分解质因数。例如：输入90，打印出90=2*3*3*5。

最好是写详细的注释

1. 
   
2. package java01;
   
3. 
   
4. class Test1 {
   
5.         
   
6. 
   
7.         public static void main(String[] args) {
   
8.               int num = 90;
   
9.               System.out.print(num+"=");
   
10.               for(int i=2 ;i<=num ;i++)//分解.从1到num检查，看看是不是因子
    
11.               {
    
12.                       while(num%i==0)
    
13.                       {
    
14.                               num=num/i;
    
15.                               if(num==1)
    
16.                                       System.out.print(i);//最大的因子后不用加*
    
17.                               else
    
18.                                       System.out.print(i+"*");
    
19.                       }
    
20.               }
    
21.         }
    
22. 
    
23. }
    

复制代码

1. //定义一个获取质因数静态方法，需要传入一个Int类型的值，和一个Integer类型集合
   
2.         public static void ZhiYinShu(int num,ArrayList<Integer> nums)
   
3.         {
   
4.                 //分析可得，最小质因数除1之外，只有2，3，5
   
5.                 //所以分别判断传入的数%2，%3，%5是否等于0
   
6.                 //如果等于零，则表示该数包含该质因数
   
7.                 if(num % 2 == 0)
   
8.                 {
   
9.                         nums.add(2);
   
10.                         //然后让num 除以2
    
11.                         num = num / 2;
    
12.                 }
    
13.                 if(num % 3 ==0)
    
14.                 {
    
15.                         nums.add(3);
    
16.                         num = num / 3;
    
17.                 }
    
18.                 if(num % 5 ==0)
    
19.                 {
    
20.                         nums.add(5);
    
21.                         num = num/5;
    
22.                 }
    
23.                 //这个判断是为了控制递归，如果该数做了以上操作后 还满足以下情况则继续调用本函数
    
24.                 if(num % 3==0 ||num % 5 == 0|| num%2 == 0)
    
25.                 {
    
26.                         ZhiYinShu(num,nums);
    
27.                 }       
    
28.                 //否则就直接跳出，结束函数
    
29.                 else
    
30.                 {
    
31.                         return;
    
32.                 }
    
33.         }

复制代码

我是用递归做的

1.                 //分析可得，最小质因数除1之外，只有2，3，5，7
   
2.                 //所以分别判断传入的数%2，%3，%5是否等于0
   
3.                 //如果等于零，则表示该数包含该质因数
   
4.                 if(num % 2 == 0)
   
5.                 {
   
6.                         nums.add(2);
   
7.                         //然后让num 除以2
   
8.                         num = num / 2;
   
9.                 }
   
10.                 if(num % 3 ==0)
    
11.                 {
    
12.                         nums.add(3);
    
13.                         num = num / 3;
    
14.                 }
    
15.                 if(num % 5 ==0)
    
16.                 {
    
17.                         nums.add(5);
    
18.                         num = num/5;
    
19.                 }
    
20.                 if(num % 7 == 0)
    
21.                 {
    
22.                         nums.add(7);
    
23.                         num = num/7;
    
24.                 }
    
25.                 //这个判断是为了控制递归，如果该数做了以上操作后 还满足以下情况则继续调用本函数
    
26.                 if(num % 3==0 ||num % 5 == 0|| num%2 == 0 || num %7 == 0)
    
27.                 {
    
28.                         ZhiYinShu(num,nums);
    
29.                 }       
    
30.                 //否则就直接跳出，结束函数
    
31.                 else
    
32.                 {
    
33.                         return;
    
34.                 }
    
35.         }

复制代码

我晕  代码 不对 还有个7 忘了~~

刘峻池 发表于 2014-12-9 19:42
我晕  代码 不对 还有个7 忘了~~

然后把获取质因数的集合 把里面的元素按指定方式打印就行了  这个就不用写了吧 ~

我也做一做

刘峻池 发表于 2014-12-9 19:48
然后把获取质因数的集合 把里面的元素按指定方式打印就行了  这个就不用写了吧 ~ ...

不用看了   我理解错了  我是逗比~~  

1. //接受一个数字和Integer类型的集合
   
2.         public static void ZhiYinShu(int num,ArrayList<Integer> nums)
   
3.         {
   
4.                 //定义一个局部变量接受传来的参参数num
   
5.                 int num1 = num;
   
6.                 //循环，从2 到num1
   
7.                 for(int x = 2; x <= num1 ; x ++)
   
8.                 {
   
9.                         //如果该数不是一个质因数则循环继续，不运行后面的语句
   
10.                         if(isTrue(x))
    
11.                         {
    
12.                                 continue;
    
13.                         }
    
14.                         //当x为一个质因数时，则进入while中，
    
15.                         while(true)
    
16.                         {
    
17.                                 //判断num是否可以整除这个质因数
    
18.                                 if(num % x ==0)
    
19.                                 {
    
20.                                         //将num除以x再赋值给num
    
21.                                         num = num/x;
    
22.                                         //可以打印一下这个质因数
    
23.                                         System.out.println(x);
    
24.                                         //把这个质因数添加到集合中
    
25.                                         nums.add(x);
    
26.                                 }
    
27.                                 //一直到num无法整除这个质因数时，内部循环跳出
    
28.                                 else
    
29.                                 {
    
30.                                         break;
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35.        
    
36.         //接受一个数，判断其是否为质因数 true-->不是 ，false--> 是
    
37.         public static boolean isTrue(int num)
    
38.         {
    
39.                 for(int x = 2;x < num; x++)
    
40.                 {
    
41.                         if(num % x == 0)
    
42.                         {
    
43.                                 return true;
    
44.                         }
    
45.                 }
    
46.                 return false;
    
47.         }

复制代码

这次应该对了~  上代码

这个有点没搞懂

算法会，但要把代码敲出来还有点问题，等我解决了再上传给楼主:lol

谢谢！回头我试试

我感觉可以先找出质数来~

fatesabering 发表于 2014-12-9 16:15

代码精简，不错的方法

刘峻池 发表于 2014-12-9 21:48
这次应该对了~  上代码

这次对了，你这个方法应该可以优化成递归吧

学习学习……

学习学习！

我觉得2L写的很好啊

以前老师说每个人写的代码都不一样，现在是感觉到了