一步一步写算法(之循环和递归)(转)

    其实编程的朋友知道,不管学什么语言,循环和递归是两个必须学习的内容。当然,如果循环还好理解一点,那么递归却没有那么简单。我们曾经对递归讳莫如深,但是我想告诉大家的是,递归其实没有那么可怕。所谓的递归就是函数自己调用自己而已,循环本质上也是一种递归。

    1)求和递归函数

    我们可以举一个循环的例子,前面我们说过,如果编写一个1到n的求和函数怎么写呢,你可能会这么写:

  1. int calculate(int m)  
  2. {  
  3.     int count = 0;  
  4.     if(m <0)  
  5.         return -1;  
  6.   
  7.     for(int index = 0; index <= m; index++)  
  8.         count += index;  
  9.       
  10.     return count;  
  11. }  

    上面只是一个示范。下面我们看看如果是递归应该怎么写呢?

  1. int calculate(int m)  
  2. {  
  3.     if(m == 0)  
  4.         return 0;  
  5.     else  
  6.         return calculate(m -1) + m;  
  7. }  

    大家看着两段代码有什么不同?

    (1)第一段代码从0,开始计算,从0到m逐步计算;第二段代码是从10开始计算,逐步到0之后这回,这样同样可以达到计算的效果

    (2)第一段代码不需要重复的压栈操作,第二段需要重复的函数操作,当然这也是递归的本质

    (3)第一段代码比较长,第二段代码较短

 

    2)查找递归函数

    大家可能说,这些代码有些特殊。如果是查找类的函数,有没有可能修改成递归函数呢?

  1. int find(int array[], int length, int value)  
  2. {  
  3.     int index = 0;  
  4.     if(NULL == array || 0 == length)  
  5.         return -1;  
  6.   
  7.     for(; index < length; index++)  
  8.     {  
  9.         if(value == array[index])  
  10.             return index;  
  11.     }  
  12.   
  13.     return -1;  
  14. }  

    大家可能说,这样的代码可能修改成这样的代码:

  1. int _find(int index, int array[], int length, int value)  
  2. {  
  3.     if(index == length)  
  4.         return -1;  
  5.   
  6.     if(value == array[index])  
  7.         return index;  
  8.   
  9.     return _find(index + 1,  array, length, value);  
  10. }  
  11.   
  12. int find(int array[], int length, int value)  
  13. {  
  14.     if(NULL == array || length == 0)  
  15.         return -1;  
  16.   
  17.     return _find(0, array, length, value);  
  18. }  

    3) 指针变量遍历

    结构指针是我们喜欢的遍历结构,试想如果有下面定义的数据结构:

  1. typedef struct _NODE  
  2. {  
  3.     int data;  
  4.     struct _NODE* next;  
  5. }NODE;  

    那么,此时我们需要对一个节点链接中的所有数据进行打印,应该怎么办呢?大家可以自己先想想,然后看看我们写的代码对不对。

  1. void print(const NODE* pNode)  
  2. {  
  3.     if(NULL == pNode)  
  4.         return;  
  5.   
  6.     while(pNode){  
  7.         printf("%d\n", pNode->data);  
  8.         pNode = pNode->next;  
  9.     }  
  10. }  

    那么此时如果改成递归,那就更简单了:

  1. void print(const NODE* pNode)  
  2. {  
  3.     if(NULL == pNode)  
  4.         return;  
  5.     else  
  6.         printf("%d\n", pNode->data);  
  7.       
  8.     print(pNode->next);  
  9. }  


    其实,写这么多,就是想和大家分享一下我个人的观点:循环是一种特殊的递归,只有递归和堆栈是等价的。所有的递归代码都可以写成堆栈的形式,下面的一片博客我们就讨论一下堆栈和递归的关系。要想写好,必须熟练掌握堆栈。

 

转自:http://blog.csdn.net/feixiaoxing/article/details/6838362

 

posted on 2014-02-28 10:25  仅此而已_  阅读(231)  评论(0编辑  收藏  举报

导航