1.汉诺塔问题
import javax.swing.JOptionPane;
　　public class Hanoi {
　　private static final String DISK_B = "diskB";
　　private static final String DISK_C = "diskC";
　　private static final String DISK_A = "diskA";
　　static String from=DISK_A;
　　static String to=DISK_C;
　　static String mid=DISK_B;
　　public static void main(String[] args) {
　　String input=JOptionPane.showInputDialog("please input the number of the disks you want me move.");
　　int num=Integer.parseInt(input);
　　move(num，from，mid，to);
　　}
　　private static void move(int num， String from2， String mid2， String to2) {
　　if(num==1){
　　System.out.println("move disk 1 from "+from2+" to "+to2);
　　}
　　else {
　　move(num-1，from2，to2，mid2);
　　System.out.println("move disk "+num+" from "+from2+" to "+to2);
　　move(num-1，mid2，from2，to2);
　　}
　　}
　　}
2. 这是一个排列的例子，它所做的工作是将输入的一个字符串中的所有元素进行排序并输出，例如：你给出的参数是"abc" 则程序会输出：
　　abc
　　acb
　　bac
　　bca
　　cab
　　cba
　　(1)算法的出口在于：low=high也就是现在给出的排列元素只有一个时。
　　(2)算法的逼近过程：先确定排列的第一位元素，也就是循环中i所代表的元素，
　　然后low+1开始减少排列元素，如此下去，直到low=high
　　public static void permute(String str) {
　　char[] strArray = str.toCharArray();
　　permute(strArray， 0， strArray.length - 1);
　　}
　　public static void permute(char[] list， int low， int high) {
　　int i;
　　if (low == high) {
　　String cout = "";
　　for (i = 0; i <= high; i++)
　　cout += list[i];
　　System.out.println(cout);
　　} else {
　　for (i = low; i <= high; i++) {
　　char temp = list[low];
　　list[low] = list[i];
　　list[i] = temp;
　　permute(list， low + 1， high);
　　temp = list[low];
　　list[low] = list[i];
　　list[i] = temp;
　　}
　　}
　　}
　　3。这是一个组合的例子，与上述的例子相似，只是它所做的工作是，输出所给字符串中制定数目的元素的组合种类
　　(1)程序出口在于n=1，此时只要输出目标数组的所有元素即可
　　(2)逼近过程，当n>1　的时候，我们先取第一个元素放入目标数组中，然后n-1，如此下去，最后出来。
　　import javax.swing.JOptionPane;
　　public class Combination {
　　
　　public static void main(String[] args) {
　　String input = JOptionPane.showInputDialog("please input your String： ");
　　String numString = JOptionPane.showInputDialog("please input the number of your Combination： ");
　　int num = Integer.parseInt(numString);
　　Combine(input， num);
　　}
　　private static void Combine(String input， int num) {
　　char[] a = input.toCharArray();
　　String b = "";
　　Combine(a， num， b， 0， a.length);
　　}
　　private static void Combine(char[] a， int num， String b， int low， int high) {
　　if (num == 0) {
　　System.out.println(b);
　　} else {
　　for (int i = low; i < a.length; i++) {
　　b += a[i];
　　Combine(a， num - 1， b， i+1， a.length);
　　b=b.substring(0， b.length()-1);
　　}
　　}
　　}
　　}
 
Coding多了，递归算法是非常常见的，最近我一直在做树形结构的封装，所以更加的离不开递归算法。所以今天就简单说一下这个递归算法，用java实现一个非常经典的递归实例。
 
        递归算法，其实说白了，就是程序的自身调用。它表现在一段程序中往往会遇到调用自身的那样一种coding策略，这样我们就可以利用大道至简的思想，把一个大的复杂的问题层层转换为一个小的和原问题相似的问题来求解的这样一种策略。这样我们就能看到我们会用很少的语句解决了非常大的问题，所以递归策略的最主要体现就是小的代码量解决了非常复杂的问题。
 
        做过树形结构的都知道，我们有时候遇到的树是无限级别的树，这样我们就必须要利用循环和递归算法来实现无限级别的树。
 
        在做递归算法的时候，一定要把握住出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口是非常好理解的，就是一个条件，当满足了这个条件的时候我们就不再递归了。
 
       下面用一个java的实例来实现一下递归算法。
        问题描述：
 Java递归算法
       Java代码清单：
[java] 
package com.cjq.filedown; 
  
public classFab { 
   
   public static void main(String args[]){ 
      System.out.println(fab(5)); 
   } 
   
   private static int fab(int index){ 
      if(index==1 || index==2){ 
         return 1; 
      }else{ 
         return fab(index-1)+fab(index-2); 
      } 
   } 
} 
  
          运行结果：
Java递归算法
 
        程序分析：
                这个实例是非常经典的实例，主要是利用递归实现了Fibonacci数列。这个递归算法的出口是在
[java] view plaincopyprint?
if(index==1 || index==2){ 
   return 1; 
} 
                这个代码段上，如果程序的index符合条件就会停止进行递归。所以这个程序的运行流程是：
        Java递归算法
      
        程序分析到这里，递归的实现也就完成了，读者可以自己简单的做个demo，感受一下这个算法的精妙之处，其实很多人都在说算法难，难于上青天，其实掌握算法的根才是最重要的，什么是算法的根呢，就拿这个递归算法来说吧，我感觉这个根就是那个出口，只要找到这个出口所在，那么算法自然而然就能水到渠成了。