递归的狂想（菜鸟的胡思乱想）

和很多学习刚学习算法的同学来说，递归是摆在我们面前的一道坎

结合数据结构中的二叉树和图的遍历，逛了逛51cto和csdn还有一些大牛博客，总算能摸着一些头绪了。

 

递归--传递和回归

1：传递

将规模为n的问题，传递为n-1或者n-2 更小也行

   这要求解决A问题依赖于解决小A问题

   也可以是，解决A问题=解决一个小菜问题+解决小A问题

如遍历一颗二叉树，可以是遍历左子树+遍历右子树

如遍历一幅图，打印一个节点，再从它的临节点开始遍历一副少一个结点的图

 

不要以为递归只是执行一次，f(n)不能解决，f(n-1)当然也难以解决。当问题规模不断的缩小，直到n=1or n=2这样规模的问题基本就可以解决了 

举例  f(n)=f(n-1)+f(n-2)     未知

f(5)=f(4)+f(3)     未知

f(4)=f(3)+f(2)已知

f(3)=f(2)已知+f(1)已知

（感谢 Ewarder 提供）

 

2：回归

当问题的规模中出现已知，如上图，就可以将 解 带回

 

总结：引用一张觉得概括性很高的图片

（来自Wiki—

怎样解递归题目

根据题目获取递归表达式（一般采用数学归纳法，即带值慢慢找规律）

 

递归的表达式（表现形式：自己定义自己）

这里用斐波那契的例子来说明

 

f(n）=

1. 1                       （n=1)   （回归用） 递归终止条件   即当执行f（1） 终止
2. 2                        ( n=2)    （回归用） 递归终止条件  即当执行f(2)时 终止
3. f(n-1)+f(n-1)     (n>2)   （传递用）

可以看成是分段函数的编程(if语句就行了）

 

 

递归的作用

分解（依赖传递）Divide

 

 

递归与分治  Recurison <->Divide&Conqur

Ex.1 归并排序（递归）

#include<stdio.h>



void mergesort(int *num,int start,int end);// 声明一个递归函数--Divide  形参为（数组指针，数组头指针，数组尾指针）


void merge(int *num,int start,int middle,int end);// 这个函数用来将两个排好序的数组进行合并---Conqur

int main()
{
    // 测试数组
    int num[10]= {12,54,12,67,86,45,97,32,14,65};
    int i;
    // 排序之前
    printf("Before sorting:\n");
    for (i=0; i<10; i++)
    {
        printf("%3d",num[i]);
    }
    printf("\n");
    // 进行合并排序
    mergesort(num,0,9);
    printf("After sorting:\n");
    // 排序之后
    for (i=0; i<10; i++)
    {
        printf("%3d",num[i]);
    }
    printf("\n");
    return 0;
}



//这个函数用来将问题细分

void mergesort(int *num,int start,int end)
{
    int middle;
    if(start<end)
    {
        middle=(start+end)/2;  //数组中间位置的那个数  （区间上的中点）
        // 归并的基本思想
        // 排左边
        mergesort(num,start,middle);
        // 排右边
        mergesort(num,middle+1,end);
        // 合并
        merge(num,start,middle,end);
    }
}



//这个函数用于将两个已排好序的子序列合并

void merge(int *areadysort,int start,int middle,int end)
{    int * temparry=new int[end-start+1];  //动态分配内存(注意不能用a[num]的形式
     int indexA=start;
     int indexB=middle+1;
     int I=0;
     while((indexA<=middle)&&(indexB<=end))   //扫描两个序列
     {
         if  (areadysort[indexA]<=areadysort[indexB])
            
             temparry[I++]=areadysort[indexA++];
             
        else 
            if(areadysort[indexB]<=areadysort[indexA])
             temparry[I++]=areadysort[indexB++]; 
            
     }
         while(indexA<=middle)//复制没有比较完子表中的元素
                     
            temparry[I++]=areadysort[indexA++];
         while(indexB<=end)
             temparry[I++]=areadysort[indexB++];

         I=0;
         int tmp = end-start;
         while(I<=tmp)
             areadysort[start++]=temparry[I++];  //aready
          printf("%5d\n",I);
  
         
     }

Ex.2 全排列

#include <stdio.h>  

int n = 0;  //全局计数器，全排列的个数

void swap(int *a, int *b) 
{     
    int m;     
    m = *a;     
    *a = *b;     
    *b = m; 
}  
void perm(int list[], int k, int m) //m是数组最大下标，k是当前递归的标记
{     
    int i;     
    if(k > m)   //当计数器大于最大下标时，
    {          
        for(i = 0; i <= m; i++)             
        printf("%d ", list[i]); //输出的全排列是交换后的临时结果
        printf("\n");         
        n++;     
    }     
    else     
    {         
    for(i = k; i <= m; i++)         
        {             
            swap(&list[k], &list[i]); //把选好的元素放到最前面来
            perm(list, k + 1, m);
            swap(&list[k], &list[i]); //排列好之后，再换回来，等着下次交换
        }     
    } 
} 
int main() 
{     
    int list[] = {1, 2, 3};     
    perm(list, 0, 2);     
    printf("total:%d\n", n);     
    return 0; 
}

 Ex.3 快速排序

#include<stdio.h>
#include<iostream.h>

int count = 0;

void Swap(int *a,int *b)
{
    printf("Swap begin\n");int t;
    t = *a;
    *a = *b;
    *b =t;
}
int Partition( int a[],int p,int r)
{
    printf("Partition begin\n");
    int i = p; //一個指針指向數組頭部
    int j = r+1; //一個指針指向數組尾部  （+1是為了下面方便操作）
    int x = a[p];    //设置pivot
    while(true)
    {    
        while(a[++i]<x&&i<r);
        while(a[--j]>x); //(得益于+1)
            if(i>=j) break;
            Swap(&a[i],&a[j]);
    }
a[p]=a[j];
a[j]=x;//pivot落到最终位置；
return j;
}
void QuickSort( int a[],int p,int r)
{ 
    printf("%d QickSort begin\n", count++);
    int q ;  //划分位置
    if(p<r)  //待排数组中 只剩下
    {    q = Partition(a,p,r);
        QuickSort(a,p,q-1);
        QuickSort(a,q+1,r);
    }
}




void main()
{   int a[]={8,6,3,1,5,6,4,2,7};

cout<<"The array before sort:"<<endl;
for(int i=0;i<9;i++)
printf("%2d",a[i]);
printf(" OK \n");

QuickSort(a,0,8);
printf(" OK\n");

cout<<"The array after sort:"<<endl;
for(i=0;i<9;i++)
printf("%2d",a[i]);
  printf("\n");
}

递归与动态规划 Recurison <->Dinamic Programming

 Ex.2 爬楼梯（DP）

#include<iostream.h>
int table[6];   // 表格，儲存全部問題的答案。 
bool solve[6];  // 紀錄問題是否已經計算完畢 

int f(int n) 
{ 
    if (n == 0 || n == 1) 
        return 1; 

    if (solve[n]) 
        return table[n]; 

    table[n] = f(n-1) + f(n-2); // 將答案存入表格 
    solve[n] = true;            // 已經計算完畢 

    return table[n]; 
} 

void main()   //Stair_Climbing  5阶楼梯
{ 
    // initial 
    for (int i=0; i<=5; i++) 
        solve[i] = false; 

    // compute 
    cout << "爬完五階的踏法有" << f(5) << "種\n"; 


    int n;   //Stair_Climbing   5阶以下楼梯

    cout<<"请输入：一个五阶以下的楼梯\n";
    while (cin >> n && (n >= 0 && n <= 5)) 
    { 
        cout << "爬完" << n << "階的踏法"
            << "有" << f(n) << "種\n";
        cout<<"请输入：一个五阶以下的楼梯\n";   //这句必须放在最后，即下一个循环之前
    } 
}

 递归与回溯

Ex1 n皇后迭代回溯

#include <stdio.h>
#include <iostream.h>
#include <iomanip.h>
#include <math.h>

class Queen{
    friend int nQueen(int);
private:
    bool Place(int k);
    void Backtrack(void);
    void display();
    int n, //皇后个数
        * x;  //当前解        
    long sum; //当前已找到的可行方案
};

bool Queen::Place(int k)
{
  for (int j=1;j<k;j++)
    if ((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))  //不满足隐约束
           return false;
    return true;
} 

void  Queen::Backtrack(void)
{  
    x[1] = 0;
    int k = 1;
    while (k>0) {
        x[k]+=1;  //遍历所有孩子
        while((x[k]<=n)&&!(Place(k))) x[k]+=1; //对每个孩子进行尝试
        if (x[k]<=n)  //执行到这一行只有种可能，1。当前行没有可行解 2.找到一个活节点
            if (k==n){    //已经搜索到第n行（在第n行已经找到一个活节点）
                sum++;
                display();
                cout<<"\n";
            }
            else{
                k++;    //深度搜素
                x[k]=0;  
            }
            else k--;  //回溯
    }
 }

void Queen::display( ){
    //输出n个皇后在棋盘图形上的位置
    int i,j;
    int queenq[100][100];
    for ( i=1; i<=n; i++)
        for ( j=1; j<=n; j++)
            queenq[i][j] =0;  //初始化棋盘图形矩阵
    for ( i=1; i<=n; i++)
            if (x[i]) queenq[i][x[i]] =1;  //为棋盘图形矩阵赋值            

    for( i=1;i<=n;i++){  //输出棋盘图形
       cout << "(" <<" ";
       for ( j = 1; j<=n; j++)
           if(queenq[i][j]) cout << "Q" << "  ";
           else cout << "*" << "  ";
       cout << ")" << endl;
    }
}


int nQueen(int n)
{ Queen X;
  X.n = n;
  X.sum = 0;
  int *p = new int [n+1];
  for (int i = 0; i<=n; i++)
      p[i] = 0;
  X.x = p;
  X.Backtrack();
  delete [] p;
  return X.sum;
}

void main( )
{ 
  int n,sum;
  while(1){
       cout << "用迭代回溯法解n后问题"<<"\n"<<endl;
       cout << "请输入皇后的数目(不超过16个):  ";
       cin >> n;
       sum = nQueen(n); 
       cout << "一共有"<<sum<<"种情况"<<endl; 
       cout<<"\n"<<endl;
       }
}

　　n皇后递归回溯

#include <stdio.h>
#include <iostream.h>
#include <iomanip.h>
#include <math.h>

class Queen{
    friend int nQueen(int);
private:
    bool Place(int k);
    void Backtrack(int t);
    void display();
    int n, //皇后个数
        * x;  //当前解        
    long sum; //当前已找到的可行方案
};

bool Queen::Place(int k)
{
  for (int j=1;j<k;j++)
    if ((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))  //不满足隐约束
           return false;
    return true;
} 

void  Queen::Backtrack(int t)   //搜索解空间中的第t层子树（先序遍历空间树）
{  
    if (t>n) { 
        sum++;  //到达叶结点，搜索到一个解
        display();        
        cout<<'\n';
    }
    else
      for (int i=1;i<=n;i++) {
        x[t]=i;  //在第
        if (Place(t)) Backtrack(t+1);
      }
 }

void Queen::display( ){
    //输出n个皇后在棋盘图形上的位置
    int i,j;
    int queenq[100][100];
    for ( i=1; i<=n; i++)
        for ( j=1; j<=n; j++)
            queenq[i][j] =0;  //初始化棋盘图形矩阵
    for ( i=1; i<=n; i++)
            if (x[i]) queenq[i][x[i]] =1;  //为棋盘图形矩阵赋值            

    for( i=1;i<=n;i++){  //输出棋盘图形
       cout << "(" <<" ";
       for ( j = 1; j<=n; j++)
           if(queenq[i][j]) cout << "Q" << "  ";
           else cout << "*" << "  ";
       cout << ")" << endl;
    }
}


int nQueen(int n)
{ Queen X;
  X.n = n;
  X.sum = 0;
  int *p = new int [n+1];
  for (int i = 0; i<=n; i++)
      p[i] = 0;
  X.x = p;
  X.Backtrack(1);
  delete [] p;
  return X.sum;
}

void main( )
{ 
  int n,sum;
  while(1){
       cout << "用递归回溯法解n后问题"<<"\n"<<endl;
       cout << "请输入皇后的数目(不超过16个):  ";
       cin >> n;
       sum = nQueen(n); 
       cout << "一共有"<<sum<<"种情况"<<endl; 
       cout<<"\n"<<endl;
       }
}