第四次上课练习

 第一题：利用杨辉三角形原理来计算组合数
       共有三种方法：

      第一种：运用n的阶乘计算组合数

package homework;
import javax.swing.JOptionPane; 
public class Test2 {
    public static void main(String[] args){
        int n,k;
        String s=JOptionPane.showInputDialog("请输入一个正整数作为n");
        n=Integer.parseInt(s);
        String s1=JOptionPane.showInputDialog("请输入一个正整数作为k");
        k=Integer.parseInt(s1);
        JOptionPane.showMessageDialog( null, zuheshu(k,n),"在n个元素中选取k个组合的所有结果数",JOptionPane.INFORMATION_MESSAGE );
    }
    public static long zuheshu(int k,int n){
        long i;
        i=jiecheng(n)/(jiecheng(k)*jiecheng(n-k));
        return i;
    }
    public static long jiecheng(int i){
        long j=1;
        if(i!=1)
            j=i*jiecheng(i-1);
        else
            i=1;
        return j;
    }
}

      第二种：使用递推的方法用杨辉三角形计算

      第三种：使用递归的方法用组合数递推公式计算

package homework;
import javax.swing.JOptionPane; 
public class Test3 {
    public static void main(){
        int n,k;
        String s=JOptionPane.showInputDialog("请输入一个正整数作为n");
        n=Integer.parseInt(s);
        String s1=JOptionPane.showInputDialog("请输入一个正整数作为k");
        k=Integer.parseInt(s1);
        JOptionPane.showMessageDialog( null, digui(k,n),"在n个元素中选取k个组合的所有结果数",JOptionPane.INFORMATION_MESSAGE );
    }
    public static long digui(int k,int n){
        long j=0;
        if(k!=1)
            j=digui(k-1,n)+digui(k,n);
        else
            return n;
        return j;
    }
}

第二题：递归编程解决汉诺塔问题。用Java实现

package homework;

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( "
%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( "
%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

解题算法：

如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。 

如果盘数超过2个，将最后一个盘子遮起来，就很简单了，每次处理两个盘子，也就是：A->B、A ->C、B->C这三个步骤，而被遮住的部份，

其实就是进入程序的递回处理。（进入下一次递归之后，柱的相对位置就变了）

 

第三题：使用递归方式判断某个字串是否是回文（ palindrome ）

“回文”是指正着读、反着读都一样的句子。比如“我是谁是我”
使用递归算法检测回文的程序如下：

package practice3;
4 import javax.swing.JOptionPane;
5 public class Palindrome {  
6     
7     public static void main(String[] args){  
8         String test=JOptionPane.showInputDialog( "请输入需要判断的字符串：" );
9         int i = 0;  
10         int j = test.length() - 1;  
11         String output1=" ";
12         if(isPalindrome(test, i, j))
13         {
14             output1="是";
15         }
16         else
17         {
18             output1="否";
19         }
20         String output= test + " 是否是回文字符串? 
" +output1;
21         JOptionPane.showMessageDialog(null, output,
22                 "结果如下：",
23                 JOptionPane.INFORMATION_MESSAGE );
24          
25     }  
26     //判断是否是回文字符串的方法：
27     public static boolean isPalindrome(String s,int i,int j){  
28         if(i > j)  
29             throw new IllegalArgumentException();  
30         if(i == j)  
31             return true;  
32         else{  
33             return (s.charAt(i) == s.charAt(j)) && isPalindrome(s,i+1,j-1);  
34         }  
35     }  
36       
37 }