数据结构——递归的应用（累加和汉诺塔问题）

什么是递归

递归，就是在运行的过程中调用自己。

构成递归需具备的条件：
1. 子问题须与原始问题为同样的事，且更为简单；
2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

累加

#include <stdio.h>

/**
 * Recursive addition.
 */
int addTo(int paraN) {
	int tempSum;
	printf("entering addTo(%d)\r\n", paraN);
	if (paraN <= 0) {
		printf(" return 0\r\n");
		return 0;
	} else {
		tempSum = addTo(paraN - 1) + paraN;
		printf(" return %d\r\n", tempSum);
		return tempSum;
	}// Of if
}// Of addTo

/**
 * A clear version.
 */
int clearAddTo(int paraN) {
	if (paraN <= 0) {
		return 0;
	} else {
		return clearAddTo(paraN - 1) + paraN;
	}// Of if
}// Of clearAddTo

/**
 * Test the addTo function.
 */
void addToTest() {
	int n, sum;
    printf("---- addToTest begins. ----\r\n");

	n = 5;
	sum = addTo(n);
    printf("\r\n0 adds to %d gets %d.\r\n", n, sum);

	n = 1;
	sum = addTo(n);
    printf("\r\n0 adds to %d gets %d.\r\n", n, sum);

	n = -1;
	sum = addTo(n);
    printf("\r\n0 adds to %d gets %d.\r\n", n, sum);


    printf("---- addToTest ends. ----\r\n");
}// Of addToTest

/**
 The entrance.
 */
void main() {
	addToTest();
}// Of main

这种累加的时间复杂度与 for 循环的一致, 均为 O ( n ), 但空间复杂度为 O ( n ) , 比 for 循环的 O ( 1 ) 高. 使用的栈空间.

运行结果

---- addToTest begins. ----
entering addTo(5)
entering addTo(4)
entering addTo(3)
entering addTo(2)
entering addTo(1)
entering addTo(0)
 return 0
 return 1
 return 3
 return 6
 return 10
 return 15

0 adds to 5 gets 15.
entering addTo(1)
entering addTo(0)
 return 0
 return 1

0 adds to 1 gets 1.
entering addTo(-1)
 return 0

0 adds to -1 gets 0.
---- addToTest ends. ----
Press any key to continue

汉诺塔问题

#include <stdio.h>

/**
 * Hanoi.
 */
void hanoi(int paraN, char paraSource, char paraDestination, char paraTransit) {
	if (paraN <= 0) {
		return;
	} else {
		hanoi(paraN - 1, paraSource, paraTransit, paraDestination);
		printf("%c -> %c \r\n", paraSource, paraDestination);
		hanoi(paraN - 1, paraTransit, paraDestination, paraSource);
	}// Of if
}// Of hanoi

/**
 * Test the hanoi function.
 */
void hanoiTest() {
    printf("---- addToTest begins. ----\r\n");

	printf("2 plates\r\n");
	hanoi(2, 'A', 'B', 'C');

	printf("3 plates\r\n");
	hanoi(3, 'A', 'B', 'C');

    printf("---- addToTest ends. ----\r\n");
}// Of addToTest

/**
 The entrance.
 */
void main() {
	hanoiTest();
}// Of main

算法的时间复杂度是  O(2^n) , 空间复杂度是 O(n)

运行结果

---- addToTest begins. ----
2 plates
A -> C
A -> B
C -> B
3 plates
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
---- addToTest ends. ----
Press any key to continue

总结：

递归是一种很方便的代码实现方式，但是当调用递归的次数越来越多时，会占用大量的时间和空间，对返回值进行操作时，也会额外消耗时间，如果层级过深或者递归的出口没有设置正确，我们很可能保存过多的临时变量，导致栈溢出。

事实上，函数调用的参数是通过栈空间来传递的，在调用过程中会占用线程的栈资源。而递归调用，只有走到最后的结束点后函数才能依次退出，而未到达最后的结束点之前，占用的栈空间一直没有释放，如果递归调用次数过多，就可能导致占用的栈资源超过线程的最大值，从而导致栈溢出，导致程序的异常退出。