JAVA中方法的定义与使用（课堂学习归纳）
组合数，百度词条是这样解释的：从m个不同元素中取出n（n≤m）个元素的所有组合的个数，叫做从m个不同元素中取出n个元素的组合数（Combination）
对于计算组合数，需要一定的工作量，计算机可以很好的帮助我们机选组合数，下面总结3种Jav计算组合数的方法；
一：
源代码如下：
package bky_1;
import javax.swing.JOptionPane;
public class zuheshu {
public static int factorial(int x)
{
if(x==1||x==0)
{
return 1;
}
return factorial(x-1)*x;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n,k,w;//组合数的上上下限,w表示组合数结果
String n1,n2;
System.out.println("请输入组合数的上下限");
n1=JOptionPane.showInputDialog("enter the upper number");
k=Integer.parseInt(n1);
n2=JOptionPane.showInputDialog("enter the lower number");
n=Integer.parseInt(n2);
w=factorial(n)/(factorial(k)*factorial(n-k));
System.out.println("组合数结果为"+w);
}
}
介绍：
利用计算阶乘函数的方法，通过公式C（k/n）=n!/(k!*(n-k)!),得到组合数结果。
二：
源代码：
package bky_2;
public class zuheshu2 {
public static int factorial(int x,int y)
{
int i,j;
int a[][]=new int[20][20];
for(i=0;i<20;i++)
{a[i][0]=1;}
for(i=1;i<20;i++)
{a[i][i]=1;}
for(i=2;i<20;i++)
for(j=1;j<i;j++)
{a[i][j]=a[i-1][j-1]+a[i-1][j];}
return a[x][y];
}
public static void main(String[] args) {
int w;
w=factorial(8,2);
System.out.println("计算下限20以内的组合数");
System.out.println("C(2/8)=");
System.out.println(w);
}
}
介绍：利用杨辉三角的性质，定义二维数组，直接输出对应的组合数结果。
三：
源代码：
package bky_3;
public class zuheshu3 {
public static int factorial(int x,int y)
{
int a[][]=new int [20][20];
if(y==0||x==y)
{return 1;}
return factorial(x-1,y-1)+factorial(x-1,y);
}
public static void main(String[] args) {
// TODO Auto-generated method
System.out.println("计算20以内的组合数");
System.out.println("C(8/2)");
System.out.println(factorial(8,2));
}
}
介绍：
利用递归函数的性质，递归的调用函数，得到最后组合数的结果。递归函数为
public static int factorial(int x,int y)
{ int a[][]=new int [20][20];
if(y==0||x==y) {return 1;}
return factorial(x-1,y-1)+factorial(x-1,y); }
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。在Java中，可以利用递归函数进行运行。
源代码：
// TowersOfHanoi.java
// Towers of Hanoi solution with a recursive method.
public class TowersOfHanoi
{
// recursively move disks between towers
public static void solveTowers( int disks, int sourcePeg,
int destinationPeg, int tempPeg )
{
// base case -- only one disk to move
if ( disks == 1 )
{
System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg );
return;
} // end if
// recursion step -- move (disk - 1) disks from sourcePeg
// to tempPeg using destinationPeg
solveTowers( disks - 1, sourcePeg, tempPeg, destinationPeg );
// move last disk from sourcePeg to destinationPeg
System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg );
// move ( disks - 1 ) disks from tempPeg to destinationPeg
solveTowers( disks - 1, tempPeg, destinationPeg, sourcePeg );
} // end method solveTowers
public static void main( String[] args )
{
int startPeg = 1; // value 1 used to indicate startPeg in output
int endPeg = 3; // value 3 used to indicate endPeg in output
int tempPeg = 2; // value 2 used to indicate tempPeg in output
int totalDisks = 3; // number of disks
// initial nonrecursive call: move all disks.
solveTowers( totalDisks, startPeg, endPeg, tempPeg );
} // end main
} // end class TowersOfHanoi
“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数（palindrome number）。在Java中，可以用递归函数，判断一个字符串是否为回文的。
源代码：
package bky_4;
import java.util.Scanner;
public class huiwenshu {
public static boolean huiwenshu(String text)
{
int length=text.length();
for(int i=0;i<length/2;i++)
{
if(text.charAt(i)!=text.charAt(length-i-1))
{
return false;
}
}
return true;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入一个字符串：");
Scanner s=new Scanner(System.in);
String str=null;
str=s.next();
if(huiwenshu(str))
{System.out.println("是回文数");}
else{System.out.println("不是回文数");}
}
}
