课程作业02

 

课后作业一：

 

 

设计思想：

  组合数的计算可以直接用N!来做，调用阶乘的方法，阶乘的方法有递推与递归两种，递推法就是简单的循环i从n-1递减到1，与原值相乘，递归法就是递归调用法来求，组合数的计算还可以用杨辉三角计算出推导公式，（2）中的式子，再结合递归调用的方法。

程序流程图：

 

程序代码：

  package zuhe;

import java.util.Scanner;

public class zuheshu {

 

    /*public int jiecheng1(int a,int b)

    {//异常处理

        if(a==0||b==0)

        {

           return 1;

        }

        if(a<0||b<0)

        {

           return 0;

        }

        if(a>b)//上下标不符合规范时

        {

           return 0;

        }

    }*/

    public int jiecheng2(int n)//N的阶乘用于jiecheng1的调用

    {

        for(int i=n-1;i>=1;i--)

        {

           n=n*i;

        }

        return n;

    }

    public int hui(int number)//递推

    {         

           if(number<=1)

           {

               return 1;

           }

           else

           {

               return (number * hui(number - 1));

           }

        }

    public int digui(int a,int b)//递归调用,a,b分别为组合数的上标与下标

    {

        if(a==0||b==0)//上下标为0时，返回结果1。作为递归到底时的基础数

        {

           return 1;

        }

        if(a>b)//上下标不符合规范时

        {

           return 0;

        }

        if(a==b)//递归到底时的基础数

        {

           return 1;

        }

        return (digui(b-1,a)+digui(b-1,a-1));

    }

    public static void main(String[] args)

    {

        zuheshu h=new zuheshu();

        int x;

        int y;

        //System.out.println('0');

        System.out.println("请输入组合数的上标");

        Scanner g=new Scanner(System.in);

        x=g.nextInt();

        System.out.println("请输入组合数的下标");

        y=g.nextInt();

        System.out.println("用n！的方法得：");

        //System.out.println(h.jiecheng2(3));

    System.out.println(h.jiecheng2(y)/(h.jiecheng2(x)*(h.jiecheng2(y-x))));

        System.out.println("用递归法求n！的方法得");

        System.out.println(h.hui(y)/(h.hui(x)*(h.hui(y-x))));

        System.out.println("用递归法得：");

        System.out.println(h.digui(x, y));

    }

}

结果截图：

 

 

课后作业二

 

 

设计思想;

  将n个木块从A座移动到C座，需要移动2^n次；

（1）     先将n-1个木块从A座移动到B座；

（2）     再将最后第n个木块移动到C；

（3）     再把n-1个木块从B座移动到C座；

  再按照以上的步骤

（1）     先将n-2个木块从A座移动到B座；

（2）     再将最后第n-1个木块移动到c座；

（3）     再把n-2个木块从B座移动到C座；

   再按照以上步骤……

  多次调用相似的结构，就可以用递归调用来解决

流程图：

代码：

package hannuo;

import java.util.Scanner;

public class hannuota {

 

    public static void main(String[] args)

    {

        System.out.println("输入A塔的木块数量：");

        Scanner number=new Scanner(System.in);

        int n=number.nextInt();//输入A塔的木块数

        hannuota h=new hannuota();

        System.out.println("操作步骤：");

        h.hannuo(n,'A','B','c');//调用汉诺塔函数

        System.exit(0);

    }

    public void hannuo()

    {}

    public void hannuo(int m,char a,char b,char c)//将m个木块从A借助B移动到C

    {

        if(m==1)

           move(a,c);

        else

        {

           hannuo(m-1,a,c,b);

           move(a,c);

           hannuo(m-1,b,a,c);

        }

       

    }

    public void move (char x,char y)//定义move函数

    {

        System.out.println(x+"->"+y);

    }

}

结果截图：

 

 

课程作业三：

 

 

设计思想：

 

回文序列需要判断第一个与倒数第一个元素比较，偶数列与奇数列的比较方法相同，只有前后的元素都相同才会被认定为回文序列，，这种具有相同方法的检验可以用递归调用来实现，不用考虑元素的个数，用循环来实现检验。

流程图：

 

 

代码：

package huiwen;

 

public class huiwenxulie {

    public static boolean isHuiwen(char[]a,int start,int end){

        if (start >=end) {

           return true;

        }else{

           if (a[start]==a[end]) {

               return isHuiwen(a, start+1, end-1);

           }else{

               return false;

           }

        }

    }

    public static void main(String[]args){

        char a[] = {'我','是','谁','是','我'};

        if (isHuiwen(a, 0, a.length-1))

          

           System.out.println("该序列是回文序列");

        else

           System.out.println("该序列不是回文序列");

        }

}

结果截图：