数据结构（Java）——递归

回忆的伤，挂在窗；曾经的梦，太忧伤。

1.递归的入门学习

    递归是一种功能强大的编程技术，能为某些问题提供优雅的解决方案。在各种数据结构的实现以及数据的查找和排序的处理中，递归特别有用。
    递归是一种编程技术，它利用一个方法来调用自身来满足整个作用。能够递归编程取决于能否递归的思考。
    任何递归定义都必须有一个非递归部分，这个非递归部分称为基本情形，它使得递归最终会终止。
    数学和数学公式常常会递归的表示。深刻理解递归，对于编程和解决一些逻辑上直接求解十分复杂的问题十分有效。

2.递归编程

举例说明：一个累加过程的java递归算法的实现。

package ds.java.ch08;
/** 
 * @author LbZhang
 * @version 创建时间：2015年11月18日 下午8:17:07 
 * @description 类说明
 */
public class SUMTest {
    public int sum(int num){
        int result=0;
        if(num==1){
            result=1;
        }else{
            result=num+sum(num-1);
        }
        return result;
    }

    public static void main(String[] args) {
        SUMTest sumt= new SUMTest();
        int sum=sumt.sum(10);
        System.out.println(sum);
    }

}

递归和迭代，递归是某些问题优雅恰当的解决方式，但是在某些问题中使用递归没有迭代显得直观。
所有问题都可以使用迭代解决，不过有些情况下使用递归太复杂了。
递归可以分为直接递归和间接递归。

3.递归的使用

3.1使用递归解决迷宫问题

/**
     * 递归的方式发现迷宫路径
     * @param row
     * @param column
     * @return
     */
    public boolean recursionTrvaverse(int row, int column) {

        boolean done = false;

        if (maze.valid(row, column)) {

            maze.tryPosition(row, column);///先表示当前的结点已经遍历

            if (row == maze.getRows() - 1 && column == maze.getColumns() - 1) {
                done = true; // the maze is solved
            } else {
                done = recursionTrvaverse(row + 1, column);// down
                if (!done) {
                    done = recursionTrvaverse(row, column + 1);// right
                }
                if (!done) {
                    done = recursionTrvaverse(row - 1, column);// up
                }
                if (!done) {
                    done = recursionTrvaverse(row, column - 1);// left
                }
            }
            //在正确的遍历路线上面能够形成一条路径
            if (done)
                maze.makePath(row, column);

        }

        return done;
    }

3.2使用递归解决汉诺塔问题

package ds.java.ch08;

/**
 * @author LbZhang
 * @version 创建时间：2015年11月18日 下午10:37:48
 * @description 汉诺塔类的核心实现
 * 
 */
public class TowersOfHanoi {

    private int totalDisks;// 盘子个数

    /**
     * Sets up the puzzle with the specified number of disks.
     * 
     * @param disks
     *            the number of disks
     */
    public TowersOfHanoi(int disks) {
        totalDisks = disks;
    }

    /**
     * Performs the initial call to moveTower to solve the puzzle. Moves the
     * disks from tower 1 to tower 3 using tower 2.
     */
    public void solve() {
        //借用2 从1 移动到3
        moveTower(totalDisks, 1, 3, 2);
    }

    /**
     * Moves the specified number of disks from one tower to another by moving a
     * subtower of n-1 disks out of the way, moving one disk, then moving the
     * subtower back. Base case of 1 disk.
     * 
     * @param numDisks
     *            the number of disks to move
     * @param start
     *            the starting tower
     * @param end
     *            the ending tower
     * @param temp
     *            the temporary tower
     */
    private void moveTower(int numDisks, int start, int end, int temp) {
        if (numDisks == 1)
            moveOneDisk(start, end);
        else {
            //将n-1个移动到辅助柱子
            moveTower(numDisks - 1, start, temp, end);
             //将第n个盘子从起始柱子 移动到 最终柱子
            moveOneDisk(start, end);
            //将n-1个从辅助柱子移动到目的柱子
            moveTower(numDisks - 1, temp, end, start);
        }
    }

    /**
     * Prints instructions to move one disk from the specified start tower to
     * the specified end tower.
     * 
     * @param start
     *            the starting tower
     * @param end
     *            the ending tower
     */
    private void moveOneDisk(int start, int end) {
        System.out.println("Move one disk from " + start + " to " + end);
    }

}

4.递归算法分析

递归算法的算法分析：在分析循环的时候，我们先判定循环体的序，然后再乘以该循环的执行次数。分析递归算法也用类似的思路。先判定递归的序（遵循递归定义的次数），再乘以递归方法体的序。

以计算整数累加（从1累加到某个正数）的递归方法为例。

public int sum(int num){
        int result=0;
        if(num==1){
            result=1;
        }else{
            result=num+sum(num-1);
        }
        return result;
    }

递归的方法体执行了一次加法计算其复杂度为O（1）。
每次调用递归算法时，num的值都会递减1，因此，这个递归方法被调用num次，因此递归的序为O（n）。