（1）使用组合数公式利用n!来计算
程序设计思想：
从键盘输入n,k的值，设计一个计算阶乘的大小，如果m是1或0，则直接返回，否则递归计算m-1阶乘，直到递归结束。
程序流程图：
代码：
import java.math.BigInteger;
import java.util.Scanner;
public class ds
{
public static BigInteger calculateK(int m)
{
if(m==1 || m==0)
{
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(m).multiply(calculateK((m-1)));
}
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.print("请输入n：");
int n=scanner.nextInt();
BigInteger f1=calculateK(n);
System.out.print("请输入k：");
int k=scanner.nextInt();
BigInteger x2=calculateK(k);
BigInteger x3=calculateK(n-k);
BigInteger x4=x2.multiply(x3);
BigInteger x5= f1.divide(x4);
System.out.println("结果："+x5);
}
}
截图：
2.使用递推的方法用杨辉三角形计算
程序设计思想：
杨辉三角的第n行的第m个的值等于该位置的元素的上一行的左右两个数的和，然后根据杨辉三角与组合数的关系即c(n,m)等于杨辉三角的第n+1的第m+1个元素的值，写出算法；
流程图：
代码：
import java.util.Scanner;
public class d
{
public static void yanghuisanjiao(int n,int m)
{
if(m==1)
{
System.out.println("结果：");
System.out.println(n);
}
else
{
n=n+1;
int a[][] = new int [n][n];
System.out.println(1);
for(int i=0;i<n;i++)
a[i][0]=1;
for(int i=1;i<n;i++)
{
System.out.print(1+" ");
for(int j=1;j<=i;j++)
{
a[i][j]=a[i-1][j]+a[i-1][j-1];
System.out.print(" "+a[i][j]);
}
System.out.println();
}
System.out.println();
System.out.println("结果：");
System.out.println(a[n-1][m]);
}
}
public static void main(String[] args) {
int m,n;
Scanner input=new Scanner(System.in);
System.out.println("请输入n：");
m=input.nextInt();
System.out.println("请输入m：");
n=input.nextInt();
if(m>n)
{
System.out.println("不在范围内");
System.out.println("请输入n：");
m=input.nextInt();
System.out.println("请输入m：");
n=input.nextInt();
}
yanghuisanjiao(n,m);
}
}
3.使用递归的方法用组合数递推公式计算
程序设计思想：
输入n,m（n>m），如果m=1，则输出结果n,如果m!=1，则递归计算，直到进行到n-m=1的时候，结束递归，输出结果。
流程图：
代码：
import java.util.Scanner;
public class d {
public static int xc(int n,int m)
{
int b;
if(m!=1)
{
while(n-m==1)
{
return n;
}
b=xc(n-1,m-1)+xc(n-1,m);
}
else
b=n;
return b;
}
public static void main(String[] args) {
int n,m;
Scanner input=new Scanner(System.in);
System.out.println("请输入n:");
n=input.nextInt();
System.out.println("请输入m:");
m=input.nextInt();
System.out.println("输出结果："+xc(n,m));
}
}
截图：
递归编程解决汉诺塔问题。用Java实现
程序设计思想：
输入盘子的数量n，如果盘子的数量是1，则直接将圆盘从A移到C，递归结束。否则递归，将A上编号为1至n-1的圆盘移到B,C做辅助塔；直接将编号为n的圆盘从A到C;递归，将B上的编号为1至n-1的圆盘移到C,A做辅助塔。
流程图：
代码：
import java.util.Scanner;
public class ddf {
public static int m=0;
public static void move (String A,int n,String C)
{
System.out.println(++m+": "+n+","+A+"->"+C);
}
public static void Hanio (int i,String A,String B,String C)
{
if(i==1)
move(A,1,C);
else
{
Hanio(i-1,A,C,B);
move(A,i,C);
Hanio(i-1,B,A,C);
}
}
public static void main(String[] args) {
String A ,B ,C ;
Scanner input=new Scanner(System.in);
System.out.println("三个盘子名称：");
A=input.next();
B=input.next();
C=input.next();
System.out.println("盘子的个数：");
int n=input.nextInt();
Hanio(n,A,B,C);
}
}
截图：
使用递归方式判断某个字串是否是回文
程序设计思想：
输入字符串，将其赋值给一个数组，然后用递归进行，若i=j，是回文字符串，否则从数组的首元素与尾元素进行比较，若相等，则进行i++与j--，直到达到判断条件i>=j(i=j是输入的字符串的长度为偶数个，i>j是输入的字符串有奇数个)，不符合判断，则跳出递归，结束进程，不是回文字符串。
流程图：
代码：
import java.util.Scanner;
public class w {
public static void huiwen(char a[],int j,int i)
{
if(i>=j)
{
if(a[i]==a[j])
System.out.println("是回文字符串");
System.exit(0);
}
if(a[i] == a[j])
huiwen(a,--j,++i);
else
{
System.out.println("不是回文字符串");
System.exit(0);
}
}
public static void main(String[] args)
{
String s;
int j;
int i=0;
Scanner input=new Scanner(System.in);
System.out.println("请输入 一个字符串：");
s=input.next();
char a[];
a=s.toCharArray();
j=a.length-1;
for( int k=0;k<s.length();k++)
{
System.out.print (a[k]);
}
huiwen(a,j,i);
}
}
截图：
