java学习class4

一. 课程作业01

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

　　A.设计思想

　　1. 输入k的值

　　2.利用已有的函数得到阶乘的数值

　　3.相除得到结果，输出结果

　　B.程序流程图

 

　　C.源程序代码

 1 /*本类用来计算组合数公式:C(k,n) = n!/(k!*(n-k)!)
 2  * 实验步骤:
 3  * 1.输入k的值
 4  * 2.利用已有的函数得到阶乘的数值
 5  * 3.相除得到结果，输出结果
 6  * */
 7 package class4;
 8 
 9 import java.math.BigInteger;
10 import java.util.Scanner;
11 
12 public class CombinationNumberFormula 
13 {
14     public static void main(String[] args) 
15     {
16         Scanner in=new Scanner(System.in);
17         
18         int k,n;
19         //输入要进行计算的k和n的值
20         System.out.print("请输入正整数k：");
21         k=in.nextInt();
22         System.out.print("请输入正整数n：");
23         n=in.nextInt();
24         
25         //对数值进行校验
26         if(k>n||k<0||n<0)
27         {
28             System.err.println("输入出错!");
29             System.exit(1);
30             
31         }
32         
33         //调用函数计算右侧的数值
34         BigInteger result = calculateN2(n).divide((calculateN2(k).multiply(calculateN2(n-k))));
35         
36         //输出结果
37         System.out.println("C(k,n)="+"n!/(k!*(n-k)!="+result);
38         
39         //关闭Scanner
40         in.close();
41         
42         
43         
44     }
45         
46     //计算n！的函数，使用的是大数据
47     private static BigInteger calculateN2(int n) 
48     {
49         if(n==1 || n==0)
50         {
51             return BigInteger.valueOf(1);
52         }
53         return BigInteger.valueOf(n).multiply(calculateN2((n-1)));
54     }
55 
56 }

 

 

　　D.结果截图

　　

 

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

　　A.设计思想　　

　　1.创建二维数组,用来存储数据

　　 2.考虑特殊情况，将第一列所有的值，行和列相等的数组的值赋值为1

　　 3.利用公式及循环,a[i][j] = a[i-1][j-1]+a[i-1][j],求出所有的值;

 　　4.输出

　　B.程序流程图

 

 

　　C.源程序代码

 1 /*实验目的:使用递推的方法用杨辉三角形计算组合数
 2  *实验步骤:
 3  *1.创建二维数组,用来存储数据
 4  *2.考虑特殊情况，将第一列所有的值，行和列相等的数组的值z
 5  *3.利用公式及循环,a[i][j] = a[i-1][j-1]+a[i-1][j],求出;
 6  * */
 7 package class4;
 8 
 9 import java.util.Scanner;
10 
11 public class YangHuiTriangle {
12 
13     
14     public static void main(String[] args) 
15     {
16         Scanner in = new Scanner(System.in);
17         
18         //输入要进行计算的行数
19         System.out.print("请输入要进行计算的行数:");
20         int line = in.nextInt();
21         
22         //输入要进行计算的列数
23         System.out.print("请输入要进行计算的列数:");
24         int columns = in.nextInt();
25         
26         //校验数值
27         if(columns>line)
28         {
29             System.err.println("输入的列超界了");
30             System.exit(1);
31         }
32         
33         //调用函数
34         usage_YangHuiTriangle((line+1),(1+columns));
35         
36         in.close();
37         
38         
39     }
40     
41     //本函数用于计算输出杨辉三角
42     private static void usage_YangHuiTriangle(int line,int columns)
43     {
44         int[][] a= new int[line+1][line+1];
45         
46         //对每个值进行赋值
47         for(int i = 0;i < line;i++)
48         {
49             for(int j = 0;j <= i;j++)
50             {
51                 if(j == 0||i==j)
52                     a[i][j] = 1;
53                 else
54                 {
55                     a[i][j] =a[i-1][j-1]+a[i-1][j]; 
56                 }
57             }
58         }
59         
60         //输出所求的值
61         System.out.print("C("+columns+","+line+")"+"="+a[line-1][columns-1]);
62         
63         
64     }
65 
66 }

 　　D.结果截图

 

 

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

　　A.设计思想 

 　　1.使用递归，就是从n步的时候思考n-1步的情况,以此类推直到第1步的情况。其中第一步的时候作为终止条件

 　　2.需要考虑的就是n到n-1步的操作，还有就是终止条件

　　 3.定义实现组合数递推公式的函数为C(k,n),本实验n步到n-1步的情况是:C(k,n) = C(k-1,n-1)+C(k,n-1);

 　　4.本实验的终止条件有两种是:a.C(k,n),k

　　B.程序流程图

 

　　　C.源程序代码

 1 /*本类是用递归来计算组合数递推公式
 2  * 实验步骤:
 3  * 1.使用递归，就是从n步的时候思考n-1步的情况,以此类推直到第1步的情况。其中第一步的时候作为终止条件
 4  * 2.需要考虑的就是n到n-1步的操作，还有就是终止条件
 5  * 3.定义实现组合数递推公式的函数为C(k,n),本实验n步到n-1步的情况是:C(k,n) = C(k-1,n-1)+C(k,n-1);
 6  * 4.本实验的终止条件有两种是:a.C(k,n),k 7  * */
 8 package class4;
 9 
10 import java.math.BigInteger;
11 import java.util.Scanner;
12 
13 public class CombinationNumberFormula3
14 {
15     public static void main(String[] args) 
16     {
17         Scanner in=new Scanner(System.in);
18         
19         int k,n;
20         //输入要进行计算的k和n的值
21         System.out.print("请输入正整数k：");
22         k=in.nextInt();
23         System.out.print("请输入正整数n：");
24         n=in.nextInt();
25         
26         //对数值进行校验
27         if(k>n||k<0||n<0)
28         {
29             System.err.println("输入出错，请重新输入!");
30             System.exit(1);
31         }
32         
33         //调用函数计算数值,并输出结果
34         System.out.println("C(k,n)的结果是:"+operation(k,n));
35         
36         //关闭Scanner
37         in.close();
38     }
39     private static BigInteger operation(int k,int n)
40     {
41         if(n==k)
42         {
43             return BigInteger.valueOf(1);
44         }
45         if(k==0)
46         {
47             return BigInteger.valueOf(1);
48         }
49         if(n==1)
50         {
51             return BigInteger.valueOf(1);
52         }
53         
54         //operation1,2分别是C(k-1,n-1),C(k,n-1)的大数据值
55         BigInteger operation1 = operation(k-1,n-1);
56         BigInteger operation2 = operation(k,n-1);
57         return operation1.add(operation2);
58     }
59         
60     
61     
62 }

　　D.结果截图

　　

 

 

二. 汉诺塔问题

　　A.设计思想

　　1.输入要进行的操作的数量,即盘子的个数

　　2.进行求每一步的操作:

　　　　a.如果将n-1个盘子看做一个盘子，那么移动最后一个盘子的步骤就是  

　　　　　　(1)将n-1个盘子移动到B柱子上

　　　　　　(2)将A盘子上的最大盘子移动到C柱子上

　　　　　　(3)将B上的盘子移动到C盘子上

 　　　　b.那么怎么将n-1个盘子从A移动到B柱子上呢?    

　　　　　　(1)将n-2个盘子移动到C柱子上

　　　　　　(2)将A盘子上的最大盘子移动到B柱子上

　　　　　　(3)将C上的盘子移动到B盘子上

　　　　c.后面以此类推

　　3.怎么将以上过程表示出来，具体是怎么把n-1个盘子移动到其他位置，怎么用java语言表示？

　　　　利用三个参数，分别表示移动的起点，移动的终点和移动的中转站

 　　4.终止条件是记录次数的 num==1

　　B.程序流程图

 

　　C.源程序代码

 1 /*实验步骤:
 2  * 1.输入要进行的操作的数量,即盘子的个数
 3  * 2.进行求每一步的操作:    a.如果将n-1个盘子看做一个盘子，那么移动最后一个盘子的步骤就是  (1)将n-1个盘子移动到B柱子上
 4  *                                                                　　　　　　　　 (2)将A盘子上的最大盘子移动到C柱子上
 5  *                                                                　　　　　　　　 (3)将B上的盘子移动到C盘子上
 6  *                     　b.那么怎么将n-1个盘子从A移动到B柱子上呢?               　　　(1)将n-2个盘子移动到C柱子上
 7  *                                                                　　　　 　　　　(2)将A盘子上的最大盘子移动到B柱子上
 8  *                                                                　　　　　　　　 (3)将C上的盘子移动到B盘子上
 9  *                    　 c.后面以此类推
10  * 3.怎么将以上过程表示出来，具体是怎么把n-1个盘子移动到其他位置，怎么用java语言表示？
11  *        利用三个参数，分别表示移动的起点，移动的终点和移动的中转站
12  * 4.终止条件是记录次数的 num==1
13  * 
14  * 
15  * 
16  * */
17 package class4;
18 
19 import java.util.Scanner;
20 
21 public class HanoiTower 
22 {
23     static private int number = 0;
24     public static void main(String[] args) 
25     {
26         Scanner in = new Scanner(System.in);
27         char A = 'A';
28         char B = 'B';
29         char C = 'C';
30     
31         //输入有多少个盘子
32         System.out.println("请输入要进行的操作数");
33         int num = in.nextInt();
34         
35         //调用函数，求出其各个步骤
36         solveHanoiTower(num,A,B,C);
37         
38         //关闭Scanner
39         in.close();
40     }
41     
42     //对存在柱子上的盘子进行移动
43     private static void move(int num,char start,char end)
44     {
45         number++;
46         System.out.println("第"+number+"步操作是将盘子从:"+start+"-->"+end);
47     }
48     
49     private static void solveHanoiTower(int num,char A,char B,char C) 
50     {
51         if(num==1)
52         {
53             move(1,A,C);
54         }
55         else
56         {
57             solveHanoiTower(num-1,A,C,B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助塔
58             move(num,A,C);                 
59             solveHanoiTower(num-1,B,A,C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助塔
60         }
61     }
62 }

 

 

　　D.结果截图

 

 

三. 回文字符串

　　A.设计思想

　　1.输入一个字符串

　　2.读取字符串的每一个字符，不包括空格

　　3.用数组将刚刚的字符存储起来

　　4.将首尾的两个字符比较，如果相等，循环到下一个，否则，输出不是回文

　　5.如果所有的首尾都相同则输出是回文

　　B.程序流程图

 

　　C.源程序代码

 

 1 /*实验目的:本类是用递归的方法来判断一个字符串是否是回文
 2  *实验步骤:
 3  *1.输入一个字符串
 4  *2.读取字符串的每一个字符，不包括空格
 5  *3.用数组将刚刚的字符存储起来
 6  *4.将首尾的两个字符比较，如果相等，循环到下一个，否则，输出不是回文
 7  *5.如果所有的首尾都相同则输出是回文
 8  *
 9  * */
10 package class4;
11 
12 import java.util.Scanner;
13 
14 public class Palindrome 
15 {
16 
17     public static void main(String[] args) 
18     {
19         Scanner in =new Scanner(System.in);
20         
21         //输入一个字符串(不能包含空格)
22         System.out.println("请输入一个字符串:");
23         String str = in.nextLine();
24         
25         //用数组将字符串的每一的字符存储起来
26         char[] character = new char[str.length()];
27         for(int i = 0;i)
28         {
29             character[i] = str.charAt(i);
30         }
31         if(isPalindrome(character,character.length)==0)
32         {
33             System.out.println("该字符串不是回文!");
34         }
35         else
36         {
37             System.out.println("该字符串是回文!");
38         }
39         
40         //关闭Scanner
41         in.close();
42         
43         
44     }
45     
46     //比较首尾两个字符，判断是否是回文数
47     private static int isPalindrome(char[] character,int i) 
48     {
49         int size = character.length;
50         if(i == size/2)
51         {
52             return 1;
53         }
54         if(character[size - i] == character[i-1])
55         {
56             return isPalindrome(character,i-1);
57         }
58         else
59             return 0;
60     }
61 
62 }

 

　　D.结果截图

 

 

转载于:https://www.cnblogs.com/tianxiayoujiu/p/7659359.html