递归--二分查找/判断奇偶数/汉诺塔问题/POJ放苹果

链接： 继续上一篇：这里点击查看上一篇。

题目5：二分查找

使用递归二分查找要注意的就是，数组本身是要有顺序的。代码如下：

#include "iostream"
using namespace std;

int Binary_Search(int *p,int low,int high,int key){
	int mid=(low+high)/2;
	if (p[mid]==key){
		return 1;
	}
	if (low>high){
		return 0;
	}
	if (key>p[mid]){
		return Binary_Search(p,mid+1,high,key);
	}
	else{
		return Binary_Search(p,low,mid-1,key);
	}
}

int main()
{
	int a[10]={1,2,3,4,5,6,7,8,9,10};
	cout<< Binary_Search(a,0,9,6)<<endl;
}

题目6：判断奇偶数

接下来的一个是正确的版本：

#include "iostream"
using namespace std;

bool IsOdd(unsigned);

bool IsEven(unsigned n){
	if (n==0){
		return 1;
	}
	else{
		return IsOdd(n-1);
	}
}//对应描述1

bool IsOdd(unsigned n){
	return !IsEven(n);
}//对应描述2

int main()
{
	int a[10]={1,2,3,4,5,6,7,8,9,10};
	cout<< Binary_Search(a,0,9,6)<<endl;
}

错误版本：

#include "stdio.h"
#include "iostream"
using namespace std;

bool isodd(unsigned n);

bool iseven(unsigned n){
	if (n==0){
		return true;
	}
	else{
		return isodd(n-1);
	}
}

bool isodd(unsigned n){
	return iseven(n-1);
}

int main()
{
	cout << iseven(887)<<endl;
}

错误原因：输入iseven(887)，最终等价于iseven(1)，等价于isodd(0),等价于iseven(-1)

修改：

#include "stdio.h"
#include "iostream"
using namespace std;

bool isodd(unsigned n);

bool iseven(unsigned n){
	if (n==0){
		return true;
	}
	else{
		return isodd(n-1);
	}
}

bool isodd(unsigned n){
	if (n==0){
		return false;
	}
	return iseven(n-1);
}

int main()
{
	cout << iseven(887)<<endl;
}

在isodd函数里面设置判断了，所以不会出现调用负数的情况。

还有，我知道那个为什么在开头要定义”bool isodd(unsigned n);"了，因为在接下来的一个函数需要调用它，如果不提前函数声明，会导致出错。

理解这个程序有三点要注意：

1、如果一个数前一个数是奇数，那么这个数是偶数

2、一个数不是偶数就是奇数

3、定义0是偶数

如果某个函数被细分成好几个函数，那么可以在更深的嵌套层次上应用递归调用。f调用g，g反过来调用f，这仍然被看做是递归。称之为交互递归。

有一种说法称之为递归跳跃的信任的重要性。不过暂时没有理解

题目7：汉诺塔问题

接连写了几个递归，现在还算是能够理解一丢丢了。

贴上代码：

#include "iostream"
using namespace std;

void move(char x,char y);
void hanoi(int n,char one,char two,char three){
	//把n个盘子从“one”移动到“three”坐，借助“two”
	if (n==1){
		move(one,three);
	}
	else{
		hanoi(n-1,one,three,two);
		move(one,three);
		hanoi(n-1,two,one,three);
	}
}

void move(char x,char y){
	//把一个盘子从“x”移动到“y”坐
	printf("%c---%c\n",x,y);
}

int main()
{
	hanoi(4,'a','b','c');
	cout <<endl;
}

结果也贴上：

题目8：POJ放球问题

题目大意：m个同样的球放在n个同样的盘子里，允许有空的盘子不放，共几种放法？

#include "iostream"
using namespace std;

int function(int m,int n){
	if (m==0){
		//没有球了，最后只有一种情况，那就是所有盘子都是空的
		return 1;
	}
	else if(m==1){
		//只剩下一个球，当然只剩下一种可能性
		return 1;
	}
	else if(n==0){
		//没有盘子，放不了
		return 0;
	}
	else{
		return function(m-n,n)+function(m,n-1);
	}
}

int main(int argc,char *argv[]){
	cout<<function(7,3)<<endl;
}

最后附上自己的理解吧：

首先，想出那个函数关系式就是很不容易的：f(m-n,n)+f(m,n-1)

f(m-n,n) : 所有盘子里面都有球。

f(m,n-1) : 至少一个盘子里面没有球。

在以前的概率课上，学过盒子里面掏出小球的问题，碰到了也不算陌生。我的感受就是第一个函数的作用是确保了有一种可能性，使得全部放进去了，至于以后嘛，我可以调用后面f(m,n-1),而f(m,n-1)又能够调用f(m,n-1-1)，同时，还又能调用f(m-(n-1))，我想这也就是递归函数的美丽之所在了。

也正是这样的想法，才有了最前面判断的几种分类:m=0;m=1;n=0，我想不是一开始就想到这几种判断的，而是基于函数得到的。

当然，基于这道题还衍生了不少题目：

这里可以点击此处文字，跳转到他们的博客，我暂时先不研究。