2017.10.13java上机

这次上机主要练习递归的使用，共有三道题：

1.第一道题：使用计算机计算组合数

其中需要用三种方式计算，分别是：使用组合数公式利用n!来计算、使用递推的方法用杨辉三角形计算和使用递归的方法用组合数递推公式计算。

在这里我分别使用三个方法，实现三种方式。

第一个方法，也就是使用组合数公式利用n!来计算组合数：

设计思想：计算n的阶乘，在计算阶乘之中，顺带记录k的阶乘和n-k的阶乘，最后计算得到结果。下面为相应代码：

        int t = this.m-this.n;//用t代替n-k
        double t1=0,m1=0,n1=0,zuheshu=0;
        double jiecheng = 1;
        for(int i = 0;i<this.m;i++)
        {
            if(i==t)t1 = jiecheng;//记录n-k的阶乘
            if(i == this.n)n1 = jiecheng;//记录k的阶乘
            jiecheng=jiecheng*(i+1);
        }
        m1 = jiecheng;//记录n的阶乘
        zuheshu = m1/(n1*t1);//计算结果
        System.out.println("结果是："+zuheshu)；

该方法的流程图：

 

第二个方法，也就是使用递推的方法用杨辉三角形计算组合数：

设计思路：利用输入的组合数和杨辉三角计算公式，先计算杨辉三角的各个值，存入一个二维数组之中，然后提取所需的组合数，下面为相应代码：

        int[][] a = new int[m+1][m+1];//创建二维数组
        for(int i = 0;i<m+1;i++)
        {    
            for(int j =i+1;j<m+1;j++)//将除三角之外的数赋值为0
            {
                a[i][j]=0;
            }
            for(int j = 0;j<=i;j++)
            {
                if(j==0)a[i][j]=1;//每行的首数字为1
                else a[i][j]=a[i-1][j-1]+a[i-1][j];//利用杨辉三角的算式计算相应组合数的值
            }
        }
        System.out.println("杨辉三角为：");//输出杨辉三角
        for(int i = 0;i<m+1;i++)
        {
            for(int j = 0;j<=i;j++)
                System.out.print(a[i][j]+" ");
            System.out.println();
        }
        System.out.println("结果是：");//输出所需的组合数
        System.out.println(a[this.m][this.n]);

下面为该方法的流程图：

 

第三个方法，就是使用递归的方法用组合数递推公式计算组合数：

设计思路：利用递归实现，那么分四种情况：

1.如果是底数与顶数相等，则值为1。

2.如果顶数为1，则值为底数。

3.如果顶数为0，则值为1。

4.如果都不是，则使用公式，调用递归。

下面为相应的代码：

    static int diguijisuan(int m1,int n1)//m1,n1分别为底数和顶数
    {
        if(m1 == n1)return 1;//情况1
        if(n1==1)return m1;//情况2
        if(n1 == 0)return 1;//情况3
        return (diguijisuan(m1-1,n1-1)+diguijisuan(m1-1,n1));//情况4，使用递归。
    }

下面为该方法的流程图：

 

最后是这个程序的结果：

第二道题：递归编程解决汉诺塔问题

设计思想：

 汉罗塔是一个非常古老的问题，至今早已解决，其方法如下：

1.如果只有一个盘子，就直接将盘子移动到最后一根柱子。

2.如果多以一个盘子，就是有n个盘子，就将n-1个盘子移动到中间的柱子。再将最后一个盘子移动到最后一根柱子，最后将n-1个盘子移动到最后一个柱子，期间借助第一根柱子来做周转。

在移动盘子的时候，就会形成递归。下面为相应代码：

void yidong(int n,char t1,char t2)//移动函数，参数为第n个盘子，从t1移动到t2
    {
        System.out.println("将第"+n+"个盘子从"+t1+"移动到"+t2);
    }
    void hanluot(int n,char a,char b,char c)//汉罗塔函数，参数为移动的盘子数，起始柱子，借助移动的柱子和终止柱子
    {
        if(n==1)yidong(1,a,c);//如果只有一个盘子，就将其移动到最终的盘子
        else
        {
            hanluot(n-1,a,c,b);//将n-1个盘子移动到中间盘子
            yidong(n,a,c);//输出移动的步骤
            hanluot(n-1,b,a,c);//将n-1个盘子从中间柱子移动到最右边的柱子
        }
    }

下面是这个程序的流程图：

 

最后是这个程序的结果截图：

第三道题：使用递归方式判断某个字串是否是回文

设计思想：

先输入一个字符串，将字符串转换为字符数组，利用递归方法判断是否为回文。下面是相应代码：

      public static boolean isHuiwen(char a[],int low,int high,int length)//参数为字符数组，首字符，尾字符，需判断的字符数组剩余的字符数
        {  
            if(length == 1 || length == 0)  
                return true;  
            if (a[low] != a[high] || low >= high)
                {  
                return false;  
            }  
              
            return isHuiwen(a, low + 1, high -1,length -2);  //比较一次后，length-2，需比较的字母后移或前移。
        }     

下面是程序的流程图：

 

最后是程序的结果截图：