递归算法实例讲解

在数学与计算机科学中，递归是指在函数的定义中使用函数自身的方法。
递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1) 递归就是在过程或函数里调用自身。
(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。在实际编程中尤其要注意栈溢出问题。

借助递归方法，我们可以把一个相对复杂的问题转化为一个与原问题相似的规模较小的问题来求解，递归方法只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。但在带来便捷的同时，也会有一些缺点，也即：通常用递归方法的运行效率不高。

递归算法实例

1、Fibonacci函数

讲到递归，我们最先接触到的一个实例便是斐波那契数列。
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …
特别指出：第0项是0，第1项是第一个1。
这个数列从第二项开始，每一项都等于前两项之和。
斐波那契数列递归法实现：

int Fib(int n) {     if(n<1)     {         return -1;     }     if(n == 1|| n == 2)     {         return 1;     }     return Fib(n-1)+Fib(n-2); }

2、汉诺塔问题

汉诺塔示意图

汉诺塔是根据一个传说形成的数学问题：

有三根杆子A，B，C。A杆上有N个(N>1)穿孔圆盘，盘的尺寸由下到上依次变小。要求按下列规则将所有圆盘移至C杆：

每次只能移动一个圆盘；

大盘不能叠在小盘上面。

提示：可将圆盘临时置于B杆，也可将从A杆移出的圆盘重新移回A杆，但都必须遵循上述两条规则。

问：如何移？最少要移动多少次？

最早发明这个问题的人是法国数学家爱德华·卢卡斯。

传说印度某间寺院有三根柱子，上串64个金盘。寺院里的僧侣依照一个古老的预言，以上述规则移动这些盘子；预言说当这些盘子移动完毕，世界就会灭亡。这个传说叫做梵天寺之塔问题(Tower of Brahma puzzle)。但不知道是卢卡斯自创的这个传说，还是他受他人启发。
若传说属实，僧侣们需要264 ? 1步才能完成这个任务；若他们每秒可完成一个盘子的移动，就需要5849亿年才能完成。整个宇宙现在也不过137亿年。
这个传说有若干变体：寺院换成修道院、僧侣换成修士等等。寺院的地点众说纷纭，其中一说是位于越南的河内，所以被命名为“河内塔”。另外亦有“金盘是创世时所造”、“僧侣们每天移动一盘”之类的背景设定。
佛教中确实有“浮屠”（塔）这种建筑；有些浮屠亦遵守上述规则而建。“河内塔”一名可能是由中南半岛在殖民时期传入欧洲的。

以下是汉诺塔问题的递归求解实现：

/*

* Project     : hannoi

* File        : main.cpp

* Author      : iCoding

*

* Date & Time : Sat Oct 06 21:01:55 2012

*

*/

using namespace std;

#include <iostream>

#include <cstdio>

void hannoi (int n, char from, char buffer, char to)

{

    if (n == 1)

    {

        cout << "Move disk " << n << " from " << from << " to " << to << endl;

    }

    else

    {

        hannoi (n-1, from, to, buffer);

        cout << "Move disk " << n << " from " << from << " to " << to << endl;

        hannoi (n-1, buffer, from, to);

    }

}

int main()

{

    int n;

    cin >> n;

    hannoi (n, 'A', 'B', 'C');

    return 0;

}

更详细解析请参考：编程解决汉诺塔问题

3、二叉树遍历

在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

一颗简单的二叉树

二叉树的遍历分为三种：前(先)序、中序、后序遍历。

设L、D、R分别表示二叉树的左子树、根结点和遍历右子树，则先(根)序遍历二叉树的顺序是DLR，中(根)序遍历二叉树的顺序是LDR，后(根)序遍历二叉树的顺序是LRD。还有按层遍历二叉树。这些方法的时间复杂度都是O(n)，n为结点个数。

假设我们有一个包含值的value和指向两个子结点的left和right的树结点结构。我们可以写出这样的过程：

先序遍历(递归实现)：

visit(node)

    print node.value

    if node.left  != null then visit(node.left)

    if node.right != null then visit(node.right)

1 2 3 4

visit(node)     print node.value     if node.left  != null then visit(node.left)     if node.right != null then visit(node.right)

 中序遍历(递归实现)：

visit(node)

    if node.left  != null then visit(node.left)

    print node.value

    if node.right != null then visit(node.right)

 后序遍历(递归实现)：

visit(node)

    if node.left  != null then visit(node.left)

    if node.right != null then visit(node.right)

    print node.value

4、字符串全排列

问题：

写一个函数返回一个串的所有排列。

解析：

对于一个长度为n的串，它的全排列共有A(n, n)=n!种。这个问题也是一个递归的问题， 不过我们可以用不同的思路去理解它。为了方便讲解，假设我们要考察的串是”abc”， 递归函数名叫permu。

思路一：

我们可以把串“abc”中的第0个字符a取出来，然后递归调用permu计算剩余的串“bc” 的排列，得到{bc, cb}。然后再将字符a插入这两个串中的任何一个空位(插空法)， 得到最终所有的排列。比如，a插入串bc的所有(3个)空位，得到{abc,bac,bca}。 递归的终止条件是什么呢？当一个串为空，就无法再取出其中的第0个字符了， 所以此时返回一个空的排列。代码如下：

typedef vector<string> vs;

vs permu(string s){

    vs result;

    if(s == ""){

        result.push_back("");

        return result;

    }

    string c = s.substr(0, 1);

    vs res = permu(s.substr(1));

    for(int i=0; i<res.size(); ++i){

        string t = res[i];

        for(int j=0; j<=t.length(); ++j){

            string u = t;

            u.insert(j, c);

            result.push_back(u);

        }

    }

    return result; //调用result的拷贝构造函数，返回它的一份copy，然后这个局部变量销毁(与基本类型一样)

}

 

思路二：

我们还可以用另一种思路来递归解这个问题。还是针对串“abc”， 我依次取出这个串中的每个字符，然后调用permu去计算剩余串的排列。 然后只需要把取出的字符加到剩余串排列的每个字符前即可。对于这个例子， 程序先取出a，然后计算剩余串的排列得到{bc,cb}，然后把a加到它们的前面，得到 {abc,acb}；接着取出b，计算剩余串的排列得到{ac,ca}，然后把b加到它们前面， 得到{bac,bca}；后面的同理。最后就可以得到“abc”的全序列。代码如下：

vs permu1(string s){

    vs result;

    if(s == ""){

        result.push_back("");

        return result;

    }

    for(int i=0; i<s.length(); ++i){

        string c = s.substr(i, 1);

        string t = s;

        vs res = permu1(t.erase(i, 1));

        for(int j=0; j<res.size(); ++j){

            result.push_back(c + res[j]);

        }

    }

    return result;

}

更详细讲解请参考：写一个函数返回一个串的所有排列

5、八皇后问题

问题：

经典的八皇后问题，即在一个8*8的棋盘上放8个皇后，使得这8个皇后无法互相攻击( 任意2个皇后不能处于同一行，同一列或是对角线上)，输出所有可能的摆放情况。

解析：

8皇后是个经典的问题，如果使用暴力法，每个格子都去考虑放皇后与否，一共有264 种可能。所以暴力法并不是个好办法。由于皇后们是不能放在同一行的， 所以我们可以去掉“行”这个因素，即我第1次考虑把皇后放在第1行的某个位置， 第2次放的时候就不用去放在第一行了，因为这样放皇后间是可以互相攻击的。 第2次我就考虑把皇后放在第2行的某个位置，第3次我考虑把皇后放在第3行的某个位置， 这样依次去递归。每计算1行，递归一次，每次递归里面考虑8列， 即对每一行皇后有8个可能的位置可以放。找到一个与前面行的皇后都不会互相攻击的位置， 然后再递归进入下一行。找到一组可行解即可输出，然后程序回溯去找下一组可靠解。

我们用一个一维数组来表示相应行对应的列，比如c[i]=j表示， 第i行的皇后放在第j列。如果当前行是r，皇后放在哪一列呢？c[r]列。 一共有8列，所以我们要让c[r]依次取第0列，第1列，第2列……一直到第7列， 每取一次我们就去考虑，皇后放的位置会不会和前面已经放了的皇后有冲突。 怎样是有冲突呢？同行，同列，对角线。由于已经不会同行了，所以不用考虑这一点。 同列：c[r]==c[j]; 同对角线有两种可能，即主对角线方向和副对角线方向。 主对角线方向满足，行之差等于列之差：r-j==c[r]-c[j]; 副对角线方向满足， 行之差等于列之差的相反数：r-j==c[j]-c[r]。 只有满足了当前皇后和前面所有的皇后都不会互相攻击的时候，才能进入下一级递归。

代码如下：

#include <iostream>

using namespace std;

int c[20], n=8, cnt=0;

void print(){

    for(int i=0; i<n; ++i){

        for(int j=0; j<n; ++j){

            if(j == c[i]) cout<<"1 ";

            else cout<<"0 ";

        }

        cout<<endl;

    }

    cout<<endl;

}

void search(int r){

    if(r == n){

        print();

        ++cnt;

        return;

    }

    for(int i=0; i<n; ++i){

        c[r] = i;

        int ok = 1;

        for(int j=0; j<r; ++j)

            if(c[r]==c[j] || r-j==c[r]-c[j] || r-j==c[j]-c[r]){

                ok = 0;

                break;

            }

        if(ok) search(r+1);

    }

}

int main(){

    search(0);

    cout<<cnt<<endl;

    return 0;

}