递归与迭代

一：例题

例题1：

题目描述：

 

#递归算法
def g(n):
    """Return the value of G(n), computed recursively.

    >>> g(1)
    1
    >>> g(2)
    2
    >>> g(3)
    3
    >>> g(4)
    10
    >>> g(5)
    22
    >>> from construct_check import check
    >>> # ban iteration
    >>> check(HW_SOURCE_FILE, 'g', ['While', 'For'])
    True
    """
    "*** YOUR CODE HERE ***"
    if n<4:
        return n
    else:
        return g(n-1)+2*g(n-2)+3*g(n-3)

#迭代算法
def g_iter(n):
    """Return the value of G(n), computed iteratively.

    >>> g_iter(1)
    1
    >>> g_iter(2)
    2
    >>> g_iter(3)
    3
    >>> g_iter(4)
    10
    >>> g_iter(5)
    22
    >>> from construct_check import check
    >>> # ban recursion
    >>> check(HW_SOURCE_FILE, 'g_iter', ['Recursion'])
    True
    """
    "*** YOUR CODE HERE ***"
    if n==1:
        return 1
    if n==2:
        return 2
    if n==3:
        return 3
    first,second,third=3,2,1
    temp=3
    num=3
    while num<n:
        num+=1
        temp=first+2*second+3*third
        third=second
        second=first
        first=temp
    return temp 

例题2：斐波那契数列的迭代和递归算法

迭代算法：

public static int FibonacciD(int num) {
        if(num <= 0) {
            return 0;
        }
        if(num == 1 || num == 2) {
            return 1;
        }
        int first = 1,second =1,third = 0;
        for(int i = 3; i<= num ;i++) {
            third = first + second;
            first = second;
            second = third;
        }
        return third;
    }

递归算法：

public static int Fibonacci(int i) {
        if(i <= 0) {
            return 0;
        }
        if(i == 1 || i == 2) {
            return 1;
        }
        return Fibonacci(i -2) + Fibonacci(i-1);
    }

 

 

二：分析

要想清楚这个问题，首先要明白：递归是什么？迭代是什么？

• 递归本质上来说，其实就是【我用我自己】，把一个问题转换为小规模的同样的问题。
• 迭代的话，就是在原来的基础上，算出来后续的东西，并没有【自己用自己】的那一步。可能是一个循环下来，前面的结果在后面跟着用。

其实这么看下来，迭代有一点动态规划的感觉。也就是说，我们把小规模的问题先算出来了，记录下来，再算大规模的。

• 而递归是我还没算出来小规模的结果，先来假设小规模的算出来了，直接把这个结果的计算过程写在了函数体中。

比如，一个斐波那契的例子：

• 递归：f(n) = f(n-1) + f(n-2)，接下来要算f(10)就直接写上f(9) + f(8)
• 迭代：先把小的算出来，把f(1), f(2), f(3), f(4)依次记录下来，再算后面的。

 三：感悟

递归：

1.最重要的就是找准基线条件，譬如在与树的相关问题中，首先就是考虑基线条件——leaves应该是怎样，再来考虑branches。

def replace_leaf(t, find_value, replace_value):
      if is_leaf(t):
        if label(t)==find_value:
            return tree(replace_value)
        else:
            return tree(label(t))
    # is_leaf(t):
       #return tree(replace_value if label(t)==find_value else label(t))
    if label(t)==find_value:
        return tree(replace_value,
        [replace_leaf(branch,find_value,replace_value) for branch in branches(t)])
    else:
        return tree(label(t),
        [replace_leaf(branch,find_value,replace_value) for branch in branches(t)])

2.考虑问题可以先简单化，从最简单的例子着手，再来考虑比较复杂的例子会是怎么样子的。譬如在树的应用中，就可以先考虑只有一个node，两个leaves的情况。