课后作业1：
（1）：
设计思想：
本题利用了数学公式将原式化为几个求阶乘的式子之间的运算，再利用递归算法求阶乘，因为1的阶乘是1，所以递归算法的结束条件就是当n等于1时，n的阶乘等于一，然后再依次计算，如此可求出n的阶乘。进而可求原式。
程序流程图：
程序源代码：
import java.math.BigInteger;
import java.util.Scanner;
public class Yanghui_1
{
public static void main(String [] args)
{
boolean p; //用于判断输入的数字是否符合条件
System.out.println("请输入n和k"); //提示用户输入n和k
Scanner input=new Scanner(System.in);
int n=input.nextInt(); //定义并给n赋值
int k=input.nextInt(); //定义并给k赋值
if(n<k) //判断输入的数据是否符合条件
p=false;
else
p=true;
while(p==false)
{
System.out.println("输入的数据不符合规则，n应该大于k，请重新输入：");
n=input.nextInt();
k=input.nextInt();
if(n<k)
p=false;
else
p=true;
}
int result1=f(k)*f(n-k); //定义第一个变量存储分母结果
int result=f(n)/result1; //定义第二个变量存储结果
System.out.println("结果为："+result);
}
public static BigInteger calculate(int n) //大数据处理
{
if(n==1||n==0)
{
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(n).multiply(calculate(n-1));
}
public static int f(int m) //利用递归进行计算
{
int c;
if(m==1)
c=1;
else
c=m*f(m-1);
return c;
}
}
结果截图：
（2）
程序设计思想;
本题利用递推思想运算，首先提示用户输入n和k，然后声明一个二维数组，数组大小为c[n+1][n+1]，然后把二维数组的第一列全赋值为1，第一行除了第一个元素外全为0，
然后通过循环以及杨辉三角的原理即c[i][j]=c[i-1][j-1]+c[i-1][j];然后计算出二维数组的各值，而所求的式子就等于对应的c[n][k].
程序流程图：
程序源代码：
import java.util.Scanner;
public class Yanghui_2
{
public static void main(String [] args)
{
boolean p;
System.out.println("请输入n和k"); //提示用户输入n和k
Scanner input=new Scanner(System.in);
int n;
int k;
n=input.nextInt(); //定义并给n赋值
k=input.nextInt(); //定义并给k赋值
if(n<k) //判断输入的数据是否符合条件
p=false;
else
p=true;
while(p==false)
{
System.out.println("输入的数据不符合规则，n应该大于k，请重新输入：");
n=input.nextInt();
k=input.nextInt();
if(n<k)
p=false;
else
p=true;
}
System.out.println("结果为："+ditui(n,k));
}
public static int ditui(int n,int k) //用递推运算
{
int c;
int sum[][]=new int[n+1][n+1];
for(int i=0;i<n+1;i++)
sum[i][0]=1;
for(int i=1;i<n+1;i++)
sum[0][i]=0;
for(int i=1;i<n+1;i++)
{
for(int j=1;j<n+1;j++)
sum[i][j]=sum[i-1][j-1]+sum[i-1][j];
}
c=sum[n][k];
return c;
}
}
结果截图：
（3）
程序设计思想：
通过杨辉三角的思想将原式化简，而计算这俩部分可以用递归思想，递归结束的条件为当n=k时，结果为1，当k=1时，结果为n,否则的话就继续化简，直到能计算结果。
程序流程图：
程序源代码：
import java.util.Scanner;
public class Yanghui_3
{
public static void main(String [] args)
{
boolean p;
System.out.println("请输入n和k"); //提示用户输入n和k
Scanner input=new Scanner(System.in);
int n=input.nextInt(); //定义并给n赋值
int k=input.nextInt(); //定义并给k赋值
if(n<k) //判断输入的数据是否符合条件
p=false;
else
p=true;
while(p==false)
{
System.out.println("输入的数据不符合规则，n应该大于k，请重新输入：");
n=input.nextInt();
k=input.nextInt();
if(n<k)
p=false;
else
p=true;
}
System.out.println("结果为："+recursion(n,k));
}
public static int recursion(int n,int k) //利用递归运算
{
int c;
if(k==n)
c=1;
else
{
if(k==1)
c=n;
else
c=recursion(n-1,k-1)+recursion(n-1,k);
}
return c;
}
}
结果截图：
课后作业2：
程序设计思想：
本题可以看做是移动盘子的问题，要把n个盘子从A处移到C处借助B，每次只能移动一个盘子，首先可以把n个盘子看做是俩个盘子：最底下的最大的盘子和其余的n-1个盘子，先把n-1个盘子移到B处，再把最大的那个移到C处，然后再把n-1个盘子用同样的方法借助A从B移到C，这样一直执行，直到所有盘子都移到了C处。代码上先写一个移动盘子的函数，该函数运用递归调用自己，结束的条件是当移动的盘子数目为1时，执行另外一个移动函数，该移动函数为从一个地方将盘子移到另一个地方。
程序流程图：
程序源代码：
import java.util.Scanner;
public class Hanoi
{
public static void main(String[] args)
{
System.out.println("请输入要移动几个盘子：");
Scanner input=new Scanner(System.in);
int sum=input.nextInt();
hanoi(sum,'A','B','C');
}
public static void hanoi(int m,char one,char two,char three) //递归函数
{
if(m==1) //递归结束条件
move(one,three);
else
{
hanoi(m-1,one,three,two); //调用自身
move(one,three);
hanoi(m-1,two,one,three);
}
}
public static void move(char x,char y) //当递归结束时执行的操作
{
System.out.println(x+"--->"+y);
}
}
结果截图：
课后作业3：
程序设计思想：
本题要判断输入的字符串是否为回文，首先声明一个字符串变量，用于存储用户输入的字符串，然后利用函数将字符串转化为char类型的数组，然后利用递归函数判断是否回文，声明一个min变量和max变量，开始时min=0；max=c.length-1，然后调用递归函数，递归结束的条件是c[min]==c[max]&&max-min==2然后输出字符串是回文，当不符合递归结束条件时就再进行一次判断，如果c[min]==c[max]就调用自身，继续判断c[min+1]==c[max-1]，否则直接输出字符串不是回文，然后结束程序。
程序流程图：
程序源代码：
import java.util.Scanner;
public class Palindrome
{
public static void main(String [] args)
{
System.out.println("请输入待检测语句："); //提示用户输入字符串
String s=new String(); //声明字符串变量
Scanner input=new Scanner(System.in);
s=input.nextLine(); //输入待检测字符串
char c[]=s.toCharArray(); //将字符串类型化为char数组类型
int min=0,max=c.length-1; //声明min和max并赋值
if(c.length%2==0) //如果length为奇数那么肯定不为回文
{
System.out.println("语句不是回文语句.");
System.exit (0);
}
else
{
judge(c,min,max); //否则调用递归函数
}
}
public static void judge(char ch[],int min,int max)
{
if(ch[min]==ch[max]&&max-min==2) //递归结束条件
{
System.out.println("该语句是回文。");
}
else
{
if(ch[min]==ch[max]) //需要调用自身的条件
judge(ch,min+1,max-1);
else
System.out.println("该语句不是回文。");
}
}
}
结果截图：
