递归（计算组合数判断回文字符串汉诺塔问题）
Posted 呵呵^~^
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了递归（计算组合数判断回文字符串汉诺塔问题）相关的知识，希望对你有一定的参考价值。
一.使用组合数公式利用n!来计算
1.设计思想
先输入整数n和k,分别用计算n！的递归的方法算出n！,k！和（n-k）！的结果，再计算n!/(k!(n-k)！！。用大数类BigInteger来表示n！,k！和（n-k）！的返回类型。最后输出计算的结果。
2.流程图
3.源程序代码
import java.util.Scanner;
import java.math.BigInteger;
public class Number1 {
static BigInteger GetN(int n ){//求n!
if(n==1 || n==0){
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(n).multiply(GetN(n-1));
}
static BigInteger GetK(int k) {//求k!
if(k==1||k==0) {
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(k).multiply(GetK(k-1));
}
static BigInteger GetN_K(int N_K) {//求（n-k）！
if(N_K==1||N_K==0) {
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(N_K).multiply(GetN_K(N_K-1));
}
public static void main(String[] args) {
BigInteger result,i;
Scanner scanner=new Scanner(System.in);
System.out.println("请输入组合式[n!/(k!*(n-k)!)]中的n和k(n和k之间用空格空开）");
int n=scanner.nextInt();
int k=scanner.nextInt();
i=GetK(k).multiply(GetN_K(n-k));//计算i=k!*(n-k)!;
result=GetN(n).divide(i);//计算result=n!/i;
System.out.println("n!/(k!*(n-k)!)="+result);
}
}
4.结果截图
二.使用递推的方法用杨辉三角形计算
1.设计思想
先输入n和k,n一定会比k大，动态申请一个大小为n的二维数组，利用杨辉三角（杨辉三角的行是n-1,列是k-1,杨辉三角二维素组的值是组合数的值）来计算组合数的值。用for循环给数组赋值。最后输出数组[n-1][k-1]的值。
2.流程图
3.源程序代码
import java.util.Scanner;
import java.math.BigInteger;
public class Number2 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入组合式[n!/(k!*(n-k)!)]中的n和k(n和k之间用空格空开）");
int n=scanner.nextInt();
int k=scanner.nextInt();
BigInteger[][] a=new BigInteger[n][n];//a[i][j]存放n!/(k!*(n-k)!的结果，i代表n,j代表k
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
if((i==0)&&(j==0))//0!/(0!*(0-0)!
a[i][j]=BigInteger.valueOf(1);
else if(j==0||j==i)
a[i][j]=BigInteger.valueOf(1);
else if(j<=i)
a[i][j]=a[i-1][j-1].add(a[i-1][j]);
else //当n小于k时，不计算n!/(k!*(n-k)!，数组a[i][j]=0
a[i][j]=BigInteger.valueOf(0);
}
}
System.out.println("n!/(k!*(n-k)!)="+a[n-1][k-1]);
}
}
4.结果截图
三.判断回文字符串
1.设计思想
先根据提示输入一段String字符串，将String型字符串转化成char[] 型字符串，再确定字符串的第一个字符下标和最后一个字符下标。再写返回值是boolean型的判断两个字符是否相等的方法，把字符串和第一个字符下标和最后一个字符下标作为形参。判断字符是否相等的函数里，依次从字符串两端到中间判断字符是否相等，若相等返回true,否则返回false。
2.程序流程图
3.程序源代码
import java.util.Scanner;
public class Huiwen {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一段字符串：");
String in=scanner.next();//输入字符串
int w=in.length()-1;//w是字符串最后一个字符的下标
char[] inn=in.toCharArray();//将String型转换成char[]型
if(isHuiwen(inn,0,w)==true) {//从两端到中间的字符串都回文
System.out.println("此字符串是回文字符串");
}
else {
System.out.println("此字符串不是回文字符串");
}
}
static boolean isHuiwen(char[] inn,int t,int w) {//判断两个字符是否相等
if((w-t)==1||(w-t)==2||(w-t)==0) {//(w-t)==1输入的字符串字符个数为偶数个,(w-t)==2输入的字符串字符个数位奇数个，(w-t)==0输入的字符串只有一个字符
if(inn[w]==inn[t]){//最中间的两个字符相等
return true;
}
else
return false;//如果判断两个字符不相等，不用再递归，返回false
}
else {
if(inn[w]==inn[t]) {
return true &&isHuiwen(inn,t+1,w-1);//如果判断的两个字符相等，在判断靠近中间的两个字符
}
else {
return false;
}
}
}
}
4.结果截图
四、汉诺塔问题
1.设计思想
在main输入汉诺塔问题中a指针上的盘子的个数，再调用递归方法输出移动盘子的次数。再用一个递归方法来写盘子从a指针上移动到c指针上的过程。a指针上按照从大到小的盘子n个，先从a指针移动到b指针上n-1个，这时最大的一个盘子再从a指针上移动到c指针上，b指针上的盘子n-1个按照从小到大的顺序排列。这时再将盘子从b盘上移动到c盘上。这是c指针上的n个盘子按照从大到小的顺序排列·。
2.程序流程图
3.程序源代码
import java.util.Scanner;
public class Tower {
public static void main(String[] args) {
System.out.println("汉诺塔问题：请输入a指针上的盘子的个数：");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int num=0,a=n,b=0,c=0;
System.out.println("将a指针上所有的盘子移到c指针上需要移动"+Yidong(num,a,b,c,n)+"次。");
}
static int Yidong(int num,int a,int b,int c,int n) {//盘子从a盘移动到c盘的过程
if(a>1) {//盘子从a指针上移到b指针上
b++;
a--;
System.out.println("把一个盘子从a指针上移到b指针上");
return Yidong(num+1,a,b,c,n);
}
else if(a==1) {//a指针上的盘子只剩一个，把a指针上的最后一个盘子移到c指针上
c++;
a--;
System.out.println("把a指针上的最后一个盘子移到c指针上");
return Yidong(num+1,a,b,c,n);
}
else if(c==n){//当所有的盘子都移动到c指针上
System.out.println("所有的盘子都移动到c指针上");
return num;
}
else{//把b指针上的盘子移动到c指针上
c++;
b--;
System.out.println("把b指针上的一个盘子移动到c指针上");
return Yidong(num+1,a,b,c,n);
}
}
}
4.结果截图
五、使用递归的方法用组合数递推公式计算组合数
1.设计思想
先输入整数n,k,然后调用计算组合数的方法输出组合数结果。在计算组合数的方法中先判断输入的n是否与k相等后k是0，若是返回1，否则利用
式进
行递推计算。
2.程序流程图
3.程序源代码
import java.util.Scanner;
import java.math.BigInteger;
public class Number3 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入组合式[n!/(k!*(n-k)!)]中的n和k(n和k之间用空格空开）");
int n=scanner.nextInt(); int k=scanner.nextInt();
System.out.println("n!/(k!*(n-k)!)="+GetNumber(n,k));
}
static BigInteger GetNumber(int n,int k) {
if(n==k||k==0) {
return BigInteger.valueOf(1);
}
else {
return GetNumber(n-1,k-1).add(GetNumber(n-1,k));
}
}
}
4.结果截图
以上是关于递归（计算组合数判断回文字符串汉诺塔问题）的主要内容，如果未能解决你的问题，请参考以下文章