递归

 

递归

什么样的问题可以用递归？
其实很多问题都可以用递归解决，例如数列的求和：

#include  < iostream >
using   namespace  std;

template  < class  T >
T    recrusive_sum(T a[],  int  idx)
{
     if (idx  ==   0 )  //  退出条件
         return  a[ 0 ];
     else
         return  a[idx]  +  recrusive_sum(a, idx  -   1 );  //  使用内层返回的结果
}

int  main( void )
{
     const   int  elem_cnt  =   100 ;
     int  a[elem_cnt];
     for ( int  i  =   0 ; i  <  elem_cnt;  ++ i)
        a[i]  =  i  +   1 ;
    cout  <<  recrusive_sum(a, elem_cnt  -   1 )  <<  endl;
     return   0 ;
}

显然，这不是一个高效的算法，我们通常用率更高的迭代法来解决上面的问题。用这个例子只是想说明，很多问题可以用递归解决。
能用递归解决的问题通常具有两个特点：
1  有退出条件
2  外层需要用到内层算出的结果(也可能是内层需要外层的计算结果，但比较少见)
最难的地方是找出外层利用内层结果的方法，这往往需要在思考问题的过程中发现规律，纸笔是不可缺少的。
另外退出条件需要拿捏准确，这也是一个容易出错的地方。

下面是求全排列和求全部子集的算法，注意以上两点在代码中的体现。

(*) 求全排列
不妨写出一个简单例子，我们用P(a,b,c)表示a,b,c的全排列，
则P(a,b,c)=
a b c
a c b
b a c
b c a
c a b
c b a
我们发现，以上结果按首字母可划分为三组，它们是
a + P(b,c)
b + P(a,c)
c + P(a,b)
其实就是第一个字母轮换，其余两个位置是剩下两个字母的全排列。“剩下两个字母的全排列”正是我们可以利用的内层结果。代码如下：

#include  < iostream >
using   namespace  std;

template  < class  T >
void     perm(T list[],  int  begin,  int  end)
{
     if (begin  ==  end){
         for ( int  i  =   0 ; i  <=  end;  ++ i)
            cout  <<  list[i]  <<   ' /t ' ;
        cout  <<  endl;
    }
     else {
         for ( int  i  =  begin; i  <=  end;  ++ i){
            swap(list[begin], list[i]);            
            perm(list, begin  +   1 , end);            
            swap(list[begin], list[i]);
        }
    }
}

int  main()
{
     char  a[]  =  { ' 1 ' ,  ' 2 ' ,  ' 3 ' ,  ' 4 ' };
     int  min_idx  =   0 ;
     int  max_idx  =   sizeof  a  /   sizeof   * a  -   1 ;
    perm(a, min_idx, max_idx);
     return   0 ;
}

(*) 求所有子集

不妨写一个简单的例子，然后从中发现规律。例如，集合{a,b,c}的子集有：
{}
{a}
{b}
{a, b}
{c}
{a, c}
{b, c}
{a, b, c}
耐心分析结果，发现：
{}                                (0)
{a} = {a} + {}                    (a)
{b} = {b} + {}                    (b)
{a, b} = {b} + {} + {a}           (b)
{c} = {c} + {}                    (c)
{a, c} = {c} + {a}                (c)
{b, c} = {c} + {b}                (c)
{a, b, c} = {c} + {a, b}          (c)
其实我们能从上面的分析过程中得到不只一条结论：
1 所有的子集总数是二项展开式系数和C(n,0)+C(n,1)+...+C(n,n)=2^n.这个结论虽然对解决本题没什么帮助，但它应该，也是最容易被注意到的。
2 我们将上面的所有子集分组，发现从最简单的空集开始，新出现的组都是新元素和之前所有组的笛卡尔积。这正是递归利用内层计算结果的地方。代码如下：

#include  < iostream >
#include  < vector >
#include  < string >
using   namespace  std;

template  < class  T >
void     subset(vector <  vector < T >   >&  res,  const  vector < T >&  src,  int  idx);

template  < class  T >
void     show_1d( const  vector < T >&  vec);

template  < class  T >
void     show_2d( const  vector <  vector < T >   >&  vec);

template  < class  T >
void     append_cartesian(vector <  vector < T >   >&  res, T appendant);

int  main()
{
    vector < string >         src;
    vector <  vector < string >   >     res;
    
    src.push_back( " c " );
    src.push_back( " b " );
    src.push_back( " a " );

    subset(res, src,  0 );

    show_2d(res);
     return   0 ;
}

template  < class  T >
void     subset(vector <  vector < T >   >&  res,  const  vector < T >&  src,  int  idx)
{
     if (src.size()  ==  idx){        
        vector < T >  empty_set;
        res.push_back(empty_set); //  append an empty vector when reach base
    }
     else {
        subset(res, src, idx  +   1 );
        append_cartesian(res, src[idx]); // 将内层算出的结果笛卡尔积到本层
    }
}

template  < class  T >
void     append_cartesian(vector <  vector < T >   >&  res, T appendant)
{
     int  len  =  res.size();
     for ( int  i  =   0 ; i  <  len;  ++ i){
        vector < T >  tmp  =  res[i];
        tmp.push_back(appendant);
        res.push_back(tmp);
    }
}

template  < class  T >
void     show_1d( const  vector < T >&  vec)
{
    cout  <<   ' { ' ;
     for ( int  i  =   0 ; i  <  vec.size();  ++ i){
        cout  <<  vec[i];
         if (i  !=  vec.size()  -   1 )
            cout  <<   " ,  " ;
    }
    cout  <<   ' } '   <<  endl;
}

template  < class  T >
void     show_2d( const  vector <  vector < T >   >&  vec)
{
     for ( int  i  =   0 ; i  <  vec.size();  ++ i)
        show_1d(vec[i]);
}