前言:
递归是计算机科学里出现非常多的一个概念,有时候用递归解决问题看起来非常简单优雅。推荐看看《算法图解》第三章递归，举的例子比较浅显易懂

什么是递归?

递归用一种通俗的话来说就是自己调用自己，但是需要分解它的参数，
让它解决一个更小一点的问题，当问题小到一定规模的时候，
需要一个递归出口返回。
这里举一个和其他很多老套的教科书一样喜欢举的例子，阶乘函数，
阶乘函数，我觉得用它来演示再直观不过。他的定义是这样的：

我们很容易根据它的定义写出这样一个递归函数，因为它本身就是递归定义的。

1.递归必须包含一个基本的出口(base case),
  否则就会无限递归，最终导致栈溢出。
  比如这里就是n==0返回1

2.递归必须包含一个可以分解的问题(recursive case).
  要想求得fact(n),就需要用 n*fact(n-1)

3.递归必须要向着递归出口靠近(toward the base case).
  这里每次递归调用都会n-1,向着递归出口n==0靠近

调用栈

栈实现递归原理图

普通递归&尾递归

实例代码块

# -*- coding:utf-8 -*-

from collections import deque

def fact(n):
    if n == 0:
        return 1
    else:
        return n*fact(n-1)

def print_run_recursive(n):
    if n>0:
        print_run_recursive(n-1)
        print(n)

class Stack(object):
    def __init__(self):
        self._deque = deque()

    def push(self,value):
        return self._deque.append(value)

    def pop(self):
        return self._deque.pop()

    def is_empty(self):
        return len(self._deque) == 0

def print_run_use_stack(n):
    s = Stack()
    while n>0:
        s.push(n)
        n-=1

    while not s.is_empty():
        print(s.pop())


print_run_use_stack(10)

'''
    输出结果:
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
'''

汉诺塔问题

我们把它转换成代码

def haoni_move(n,source,dest,intermediate):
    if n >= 1:
        haoni_move(n-1,source,intermediate,dest)
        print("Move %s --> %s" % (source,dest))
        haoni_move(n-1,intermediate,dest,source)
    haoni_move(3,'A','C','B')

#输出,建议你手动模拟一下，三个盘子 A(source),B(intermediate),
#C(Destination)

'''
    Move A --> C
    Move A --> B
    Move C --> B
    Move A --> C
    Move B --> A
    Move B --> C
    Move A --> C

'''