第三讲课后题

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

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

package practice3;
//使用组合数公式利用n!来计算
//@吕鹏博    2016年10月15日20:14:49
import javax.swing.JOptionPane;
public class YanghuiDitui {

    public static void main(String[] args) {
        String firstnumber=JOptionPane.showInputDialog( "请输入第一个数" );
        String secondnumber=JOptionPane.showInputDialog( "请输入第二个数" );
        int number1 = Integer.parseInt( firstnumber ); 
        int number2 = Integer.parseInt( secondnumber );
        int max;
        int min;
        if(number1>number2)
        {
            min=number2;
            max=number1;
        }
        else
        {
            max=number2;
            min=number1;
        }
        int get=crule(min,max);
        String output="组合数最终的结果为：";
        output+=get;
        JOptionPane.showMessageDialog(null, output,
                 "结果如下：",
                 JOptionPane.INFORMATION_MESSAGE );

    }
    public static int crule(int number1,int number2){
        int value;
        value=jiecheng(number2)/(jiecheng(number1)*jiecheng(number2-number1));
        return value;
    }
    public static int jiecheng(int number1){
        if(number1==0||number1==1)
        {
            number1=1;
        }
        else
        {
            number1=number1*jiecheng(number1-1);
        }
        return number1;
    }

}

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

package practice3;
//使用递推的方法用杨辉三角形计算
//@吕鹏博   2016年10月15日20:50:01
import javax.swing.JOptionPane;
public class Yanghui2 {
    static int C[][] = new int[1 << 10][1 << 10];
    public static void main(String[] args) {

            String firstnumber=JOptionPane.showInputDialog( "请输入第一个数" );
            String secondnumber=JOptionPane.showInputDialog( "请输入第二个数" );
            int number1 = Integer.parseInt( firstnumber ); 
            int number2 = Integer.parseInt( secondnumber );
            int max;
            int min;
            if(number1>number2)
            {
                min=number2;
                max=number1;
            }
            else
            {
                max=number2;
                min=number1;
            }
            C[0][0] = 1;  
            for (int i = 1; i <= max; i++) {  
                C[i][0] = 1;  
                C[i][i] = 1; 
                for (int j = 1; j <= min; j++) {  
                    C[i][j] = C[i - 1][j - 1] + C[i - 1][j];  
                }  
            }  
            String output="组合数C["+max+"]["+min+"]最终的结果为：";
            output+=C[max][min];
            JOptionPane.showMessageDialog(null, output,
                     "结果如下：",
                     JOptionPane.INFORMATION_MESSAGE );
            
            
            

        
    }
}
    

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

package practice3;
//使用递归的方法用组合数递推公式计算
//@吕鹏博   2016年10月15日21:04:57
import javax.swing.JOptionPane;
public class Yanghui3 {

    public static void main(String[] args) {
        String firstnumber=JOptionPane.showInputDialog( "请输入第一个数" );
        String secondnumber=JOptionPane.showInputDialog( "请输入第二个数" );
        int number1 = Integer.parseInt( firstnumber ); 
        int number2 = Integer.parseInt( secondnumber );
        int max;
        int min;
        if(number1>number2)
        {
            min=number2;
            max=number1;
        }
        else
        {
            max=number2;
            min=number1;
        }
        int get=crule(max,min);
        String output="组合数C["+max+"]["+min+"]最终的结果为：";
        output+=get;
        JOptionPane.showMessageDialog(null, output,
                 "结果如下：",
                 JOptionPane.INFORMATION_MESSAGE );

    }
    public static int crule(int number1,int number2){
        if(number2==0||number2==number1)
        {    
             return 1;
        }
        else
        {
             return crule(number1-1,number2-1)+crule(number1-1,number2);
        }
    }

}

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

package practice3;
//汉诺塔问题的步骤
//@吕鹏博     2016年10月15日19:58:33
public class TowersOfHanoi {
     // recursively move disks between towers
       public static void solveTowers( int disks, int sourcePeg, 
          int destinationPeg, int tempPeg )
       {
          
          if ( disks == 1 )
          {
             System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg );
             return;
          } 

          
          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

解题算法：

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

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

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

 

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

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

package practice3;
//使用递归方式判断某个字串是否是回文（ palindrome ）
//@吕鹏博    2016年10月15日21:15:04
import javax.swing.JOptionPane;
public class Palindrome {  
    
    public static void main(String[] args){  
        String test=JOptionPane.showInputDialog( "请输入需要判断的字符串：" );
        int i = 0;  
        int j = test.length() - 1;  
        String output1=" ";
        if(isPalindrome(test, i, j))
        {
            output1="是";
        }
        else
        {
            output1="否";
        }
        String output= test + " 是否是回文字符串? \n" +output1;
        JOptionPane.showMessageDialog(null, output,
                "结果如下：",
                JOptionPane.INFORMATION_MESSAGE );
         
    }  
    //判断是否是回文字符串的方法：
    public static boolean isPalindrome(String s,int i,int j){  
        if(i > j)  
            throw new IllegalArgumentException();  
        if(i == j)  
            return true;  
        else{  
            return (s.charAt(i) == s.charAt(j)) && isPalindrome(s,i+1,j-1);  
        }  
    }  
      
}  

 

 

课上总结：

“递归”是“由后至前再回来”，要求第n项，先求第n-1项，……，倒推到前面的可计算出的某项，然后再返回。

递推”是“从前到后”，先求第1项，然后，在此基础上求第2项，第3项，直至第n项，通常可以直接使用循环语句实现。
每个递归函数的开头一定是判断递归结束条件是否满足的语句（一般是if语句）；
函数体一定至少有一句是“自己调用自己”的。
每个递归函数一定有一个控制递归可以终结的变量（通常是作为函数的参数而存在）。每次自己调用自己时，此变量会变化（一般是变小），并传送给被调用的函数。

Java支持可变参数的方法

public static double max(double ... values) 
{ 
double largest=Double.MIN_VALUE;
 for (double v:values)
             if(v>largest) 
                largest=v; 
return largest; 
}
        

System.out.println("Max:"+max(1,11,300,2,3));

生成随机数的方法：

关于程序在另一篇博文中写出。