02方法(递归)课程作业01、02、03

(一)背景:杨辉三角形与组合数公式

 

杨辉三角形:

package 杨辉三角形;
//信1605-2 20163588 王金萱
import java.util.Scanner;
public class Yanghui {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n;
        Scanner in=new Scanner(System.in);
        System.out.print("请输入要生成的杨辉三角的行数:");
        n=in.nextInt();
        int triangle[][]=new int[n][];
        for(int i=0;i<n;i++)
        {
            triangle[i]=new int [i+1];
            for(int j=0;j<=i;j++)
            {
                if(i==0||j==0||j==i)
                {
                    triangle[i][j]=1;
                }
                else
                {
                    triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];
                }
            }
        }
        for(int i=0;i<n;i++)
            for(int j=0;j<=i;j++)
            {
                System.out.print(triangle[i][j]+" ");
                if(j==i)
                {
                    System.out.println();
                }
            }
    }

}

执行结果:

 

使用计算机计算组合数:

(1)使用组合数公式利用n!来计算

 

  1. 设计思想

用户输入组合数的下标n,上标k;

运用递归方法分别将n!,k!,(n-k)!算出,然后按上图方法计算结果后输出。

 

  2.程序流程图              

                                                                                                                                                                                     

  3.源程序代码

 1 package 计算组合数;
 2 
 3 //信1605-2 20163588 王金萱
 4 
 5 import java.util.Scanner;
 6 
 7 import java.math.BigDecimal;
 8 
 9 public class Zuheshu1 {
10 
11        public BigDecimal f(int n)//阶乘
12 
13        {
14 
15               if(n==0||n==1)
16 
17               {
18 
19                      return BigDecimal.valueOf(1);
20 
21               }
22 
23               else
24 
25               {
26 
27                      return BigDecimal.valueOf(n).multiply(f(n-1));
28 
29               }
30 
31        }
32 
33        public static void main(String[] args) {
34 
35               // TODO Auto-generated method stub
36 
37               System.out.print("请输入组合数的n和k:");
38 
39               Scanner in=new Scanner(System.in);
40 
41               int n=in.nextInt();//组合数的下标
42 
43               int k=in.nextInt();//组合数的上标
44 
45               BigDecimal a,b,c,d,result;
46 
47               Zuheshu1 z=new Zuheshu1();
48 
49               a=z.f(n);
50 
51               b=z.f(k);
52 
53               c=z.f(n-k);
54 
55               d=b.multiply(c);
56 
57               result=a.divide(d);
58 
59               System.out.println("组合数的结果为"+result);
60 
61        }
62 
63  
64 
65 }

  4.结果截图

 

(2)使用递推的方法用杨辉三角形计算

 

  1. 设计思想

用户输入组合数下标n和上标k,创建行数为n的二维数组,每行数据个数为行数,第一列统一均为1,每行最后一个数也均为1,其余数字根据triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1]递推,组合结果用triangle[n][k]输出。

 

  1. 程序流程图

 

 

 

 

 

  3.源程序代码

  

 1 package 计算组合数;
 2 
 3 //信1605-2 20163588 王金萱
 4 
 5 import java.util.Scanner;
 6 
 7 public class Zuheshu2 {
 8 
 9     public static void main(String[] args) {
10 
11         // TODO Auto-generated method stub
12 
13         int triangle[][]=new int[100][100];
14 
15         System.out.print("请输入组合数的n和k:");
16 
17         Scanner in=new Scanner(System.in);
18 
19         int n=in.nextInt();//组合数的下标
20 
21         int k=in.nextInt();//组合数的上标
22 
23         for(int i=0;i<=n;i++)
24 
25         {
26 
27             for(int j=0;j<=i;j++)
28 
29             {
30 
31                 if(j==0||j==i)
32 
33                 {
34 
35                     triangle[i][j]=1;
36 
37                 }
38 
39                 else
40 
41                 {
42 
43                     triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];
44 
45                 }
46 
47             }
48 
49         }
50 
51         System.out.println("组合数的结果为"+triangle[n][k]);
52     }
53 }

   4.结果截图

 

 

 

(3)使用递归的方法用组合数递推公式计算

  1. 设计思想

用户输入组合数的下标n和上标k,创建triangle[100][100]数组,

第一列统一均为1,每行最后一个数也均为1,

其余根据triangle[nn][kk]=digui(nn-1,kk)+digui(nn-1,kk-1)进行递归

最后输出digui(n, k)

  1. 程序流程图

 

  3.源程序代码

 

 1 package 计算组合数;
 2 
 3 //信1605-2 20163588 王金萱
 4 
 5 import java.util.Scanner;
 6 
 7 public class Zuheshu3 {
 8 
 9     public int digui(int nn,int kk)
10 
11     {
12 
13         int triangle[][]=new int[100][100];
14 
15         if(nn==kk||kk==0)
16 
17         {
18 
19             return 1;
20 
21         }
22 
23         else
24 
25         {
26 
27             triangle[nn][kk]=digui(nn-1,kk)+digui(nn-1,kk-1);
28 
29             return triangle[nn][kk];
30 
31         }
32 
33     }
34 
35     public static void main(String[] args) {
36 
37         // TODO Auto-generated method stub
38 
39         Zuheshu3 z=new Zuheshu3();
40 
41         System.out.print("请输入组合数的n和k:");
42 
43         Scanner in=new Scanner(System.in);
44 
45         int n=in.nextInt();//组合数的下标
46 
47         int k=in.nextInt();//组合数的上标
48 
49         System.out.print("组合数的结果为"+z.digui(n, k));
50 
51     }
52 }

  4.结果截图

 

 

(二)递归编程解决汉诺塔问题

1. 设计思想

将n个盘子从A座移到C盘可以分解为以下3个步骤:

(1)将A上的n-1个盘借助C座先移到B座上;

(2)把A座上剩下的一个盘移到C盘上;

(3)将n-1个盘从B盘借助于A座移到C座;

 

2. 程序流程图

3. 源程序代码

 

 1 package 汉诺塔问题;
 2 
 3 //信1605-2 20163588 王金萱
 4 
 5 import java.util.Scanner;
 6 
 7 public class Hanoi {
 8 
 9     public static void main(String[] args) {
10 
11         // TODO Auto-generated method stub
12 
13         int n;
14 
15         System.out.print("input the number of diskes:");
16 
17         Scanner in=new Scanner(System.in);
18 
19         n=in.nextInt();
20 
21         System.out.println("The step to move "+n+" diskes:");
22 
23         hannuota(n,'A','B','C');
24 
25     }
26 
27         public static void hannuota(int n,char one,char two,char three)
28 
29         {       //将n个盘子从one座借助two座,移到three座
30 
31             if(n==1)
32 
33             {
34 
35                 move(one,three);
36 
37             }
38 
39             else
40 
41             {
42 
43                 hannuota(n-1,one,three,two);
44 
45                 move(one,three);
46 
47                 hannuota(n-1,two,one,three);
48 
49             }
50 
51         }
52 
53         public static void move(char x,char y)
54 
55         {
56 
57             System.out.println(x+"->"+y);
58 
59         }
60 
61 }

4.结果截图

 

 

(三)使用递归方式判断某个字串是否是回文( palindrome )

1.设计思想

用户输入字符串,程序从第一个与最后一个字符配对,第二个与倒数第二个字符配对,比较是否相同,若相同,继续循环下去;若不同,则不是回文字符串。若能循环到字符串中间,则是回文字符串。

 

2.程序流程图

3.源程序代码

 

 1 package 回文字符串;
 2 
 3 //信1605-2 20163588 王金萱
 4 
 5 import java.util.Scanner;
 6 
 7 public class Huiwen {
 8 
 9     public static void main(String[] args) {
10 
11         // TODO Auto-generated method stub
12 
13         System.out.println("请输入字符串:");
14 
15         Scanner in=new Scanner(System.in);
16 
17         String str=in.next();
18 
19         int n=str.length();
20 
21         int m=huiwen(str,n);
22 
23             if(m==1)
24 
25             {
26 
27                 System.out.println("该字符串是回文字符串");
28 
29             }
30 
31             else if(m==0)
32 
33             {
34 
35                 System.out.println("该字符串不是回文字符串");
36 
37             }
38 
39         }
40 
41     public static int huiwen(String str,int n)
42 
43     {
44 
45         int a,b;
46 
47         char c1,c2;
48 
49         a=str.length()-n;//从前到后控制下标
50 
51         b=str.length()-(a+1);//从后到前控制下标
52 
53         c1=str.charAt(a);//从前到后取字符
54 
55         c2=str.charAt(b);//从后到前取字符
56 
57             if(b==n/2)
58 
59             {
60 
61                 return 1;//可递归到中间,则为回文
62 
63             }
64 
65             if(c1!=c2)
66 
67             {
68 
69                 return 0;//一旦有对应不同的,则不是回文
70 
71             }
72 
73             return huiwen(str,n-1);
74 
75     }
76 
77 }

4.结果截图

 

 

posted @ 2017-10-13 22:50  顾北清歌寒。  阅读(400)  评论(0编辑  收藏  举报