利用阶乘公式来计算组合式：
程序设计思想：
根据公式
来计算组合数的大小，从键盘输入n,m的值，设计一个计算阶乘的大小，如果输入的数a为1或0，则直接return 1，否则运用递归，计算a-1的阶乘，直到a为1时，递归结束。
程序流程图
源代码：
package 测试二;
import java.math.BigInteger;
import java.util.Scanner;
public class zuheshu1 {
public static void main(String[] args) {
System.out.print("请输入N,M(N>M)：");
Scanner scanner=new Scanner(System.in);
int number1=scanner.nextInt();
int number2=scanner.nextInt();
while(number1<number2)
{
System.out.println("输入有误，请重新输入！");
number1=scanner.nextInt();
number2=scanner.nextInt();
}
BigInteger sum,a,b,c;
a=calculateN2(number1);
b=calculateN2(number2);
c=calculateN2(number1-number2);
sum=(a.divide(b)).divide(c);
System.out.println("该组合数为结果为："+sum);
}
public static long calculateN(int n) {
if(n==1 || n==0){
return 1;
}
return n*calculateN(n-1);
}
public static BigInteger calculateN2(int n) {
if(n==1 || n==0){
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(n).multiply(calculateN2((n-1)));
}
}
结果截图：
（2）
运用公式计算组合数：
程序设计思想：
输入n,m，两个数（来组成要求出的组合数）（n>m），如果m=1，则输出结果n,如果m!=1，则进入递归，运用公式，直到进行到n-m=1的时候，结束递归，输出结果。
程序流程图：
源代码：
package 测试二;
import java.util.*;
public class zuheshu2 {
public static int C(int n,int m)
{
if(m==0||n==1||m==n) return 1;
int min=Math.min(n, n-m);
int f=1;
int f1=0;
for(int i=1;i<=min;i++)
{
f1=f*(n-i+1)/i;
f=f1;
}
return f1;
}
public static void main(String[] args)
{
System.out.println("请输入组合数C（n,m）自变量n,m");
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
System.out.println("组合数C（n,m)为"+C(n,m));
}
}
结果截图：
（3）
根据杨辉三角递推求组合数
程序设计思想：
根据杨辉三角的规律，得出杨辉三角的第n行的第m个的值等于该位置的元素的上一行的左右两个数的和，然后根据杨辉三角与组合数的关系即c(n,m)等于杨辉三角的第n+1的第m+1个元素的值，根据这个来写出组合数的值。
程序流程图：
源代码：
package 测试二;
import java.util.*;
public class zuheshu3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入组合数C（n,m）自变量n,m");
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
System.out.println("组合数C（n,m)为"+C(n,m));
}
public static int C(int n,int m)
{
if(n<0||m<0||n<m)
return 0;
if(n==m)
return 1;
if(m==1)
return n;
return C(n-1,m)+C(n-1,m-1);
}
}
结果截图：
2.汉诺塔问题
程序设计思想：
1.首先输入盘子的数量n，如果盘子的数量是1，则直接将编号为1的圆盘从A移到C，递归结束。
2.否则：
递归，将A上编号为1至n-1的圆盘移到B,C做辅助塔；
直接将编号为n的圆盘从A到C;
递归，将B上的编号为1至n-1的圆盘移到C,A做辅助塔。
程序流程图：
源代码：
package 测试二;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class hanoi {
static int count;
public static void main(String args[]) throws Exception {
int n;
BufferedReader buf =
new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入盘数：");
n = Integer.parseInt(buf.readLine());
hanoi han = new hanoi();
han.move(n, 'A', 'B', 'C');
System.out.println("总共"+count+"次");
}
public void move(int n, char a, char b, char c)
{
count++;
if (n == 1)
System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);
else {
move(n - 1, a, c, b);
System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);
move(n - 1, b, a, c);
}
}
}
结果截图：
3.
随意输入一个任意大小的字符串，判断他是不是回文字符串。
程序设计思想：
从键盘随意输入一个字符串，并将其赋值给一个数组，然后用递归进行，若i=j，泽肯定是递归，否则从数组的首元素与尾元素进行比较，若相等，则进行i++与j--，不断向中间靠拢，直到达到判断条件i>=j(i=j是输入的字符串的长度为偶数个，i>j是输入的字符串有奇数个)，中间若有一次不符合判断，直接跳出递归，结束进程，输出不是回文字符串。（i是指的字符串的第一个元素的下标，j是指的字符串的最后一个元素的下标）
程序设计流程图：
源代码：
package 测试二;
import java.util.*;
import java.util.Arrays;
public class huiwen {
public boolean Judge(String str){
//当字符串长度为1，或者为空字符串就认为是回文，这个作为已知点，长的字符串要向这个方向追溯。这也是递归的终止条件之一
if(str.length()==1||str.length()==0){
return true;
}
else if(str.charAt(0)==str.charAt(str.length()-1)){
String strShort=stringCut(str);//把字符串第一个和最后一个字符截掉
return Judge(strShort);//调用自身再进行比较
}
else
{//递归的终止条件之二：字符串的第一个字符和倒数第一个不相等的情况，直接返回false
return false;
}
}
//把字符串第一个和最后一个字符截掉
public static String stringCut(String str)
{
if(str==null||"".equals(str))
{
return "";
}
char[] src=str.toCharArray();
char[] dst=Arrays.copyOfRange(src, 1,src.length-1);
return String.valueOf(dst);
}
public static void main(String[] args) {
huiwen test=new huiwen();
System.out.println("请输入你要测试的字符串：");
Scanner in=new Scanner(System.in);
String str=in.next();
System.out.println(test.Judge(str));
}
}
结果截图：
