数据结构7-累加的递归、汉诺塔

// 累加函数采用最为简单的递归方法 
int addTo(int paraN) {
	int tempSum;
	printf("进入累加(%d)rn", paraN);
	if (paraN <= 0) {
		printf(" return 0rn ");
		return 0;
	} else {
		tempSum = addTo(paraN - 1) + paraN;
		printf(" return %drn ", tempSum);
		return tempSum;
	}
}

#include 

// 累加函数采用最为简单的递归方法 
int addTo(int paraN) {
	int tempSum;
	printf("进入累加(%d)rn", paraN);
	if (paraN <= 0) {
		printf(" return 0rn ");
		return 0;
	} else {
		tempSum = addTo(paraN - 1) + paraN;
		printf(" return %drn ", tempSum);
		return tempSum;
	}
}

void addToTest() {
	
	int n, sum;
	scanf("%d",&n);
	sum = addTo(n);
    printf("rn0 加到 %d 得到 %d.rn", n, sum);
    
}

void main() {
	
	int n;
	printf("请输入要累加的数字：");
	addToTest();
}

// 打印移动步骤
void hanoi(int paraN, char paraSource, char paraDestination, char paraTransit) {
	if (paraN <= 0) {
		return;
	} else {
		hanoi(paraN - 1, paraSource, paraTransit, paraDestination);
		printf("%c -> %c rn", paraSource, paraDestination);
		hanoi(paraN - 1, paraTransit, paraDestination, paraSource);
	}
}

// 计算移动总次数
int movehanoi(int paraN) {
	
	int temp;
	temp = paraN;
    if(paraN == 1){
    	temp = 1;
	}
	else{
		temp = 2*movehanoi(paraN-1)+1;
	}
    return temp; 
}

#include 

void hanoi(int paraN, char paraSource, char paraDestination, char paraTransit) {
	if (paraN <= 0) {
		return;
	} else {
		hanoi(paraN - 1, paraSource, paraTransit, paraDestination);
		printf("%c -> %c rn", paraSource, paraDestination);
		hanoi(paraN - 1, paraTransit, paraDestination, paraSource);
	}
}

int movehanoi(int paraN) {
	
	int temp;
	temp = paraN;
    if(paraN == 1){
    	temp = 1;
	}
	else{
		temp = 2*movehanoi(paraN-1)+1;
	}
    return temp; 
}

void hanoiTest() {
    
    int n;
    scanf("%d",&n);
	hanoi(n, 'A', 'B', 'C');
	
}

void main() {
	
	int n,k;
    printf("请输入放入盘子个数：");
    scanf("%d",&n);
    k = movehanoi(n);
	hanoiTest();
	printf("%d个盘子总共移动%d次",n,k);
}

1、两个问题都采用了递归的思想，且都为最简单的递归，系统会自动为递归程序建栈

2、写汉诺塔核心函数时记得加上判断条件，以防输入为非正数的情况

3、汉诺塔问题的总移动次数实质上是2^n-1次

4、累加递归的时间复杂度和空间复杂度均为O（n），而汉诺塔问题的时间复杂度为O (2^n)，空间复杂度为O（n），汉诺塔问题通过一系列的压栈弹栈，重复利用同一片空间，其空间复杂度并不比累加递归大