高级语言第十章，递归

最新推荐文章于 2024-08-30 11:28:00 发布

Niu战士

最新推荐文章于 2024-08-30 11:28:00 发布

阅读量417

点赞数 10

分类专栏：吉林大学高级语言讲义文章标签： c语言算法 c++

本文链接：https://blog.csdn.net/m0_56210953/article/details/136092382

版权

吉林大学高级语言讲义专栏收录该内容

11 篇文章 4 订阅

订阅专栏

1.编写一个函数，用递归计算Hermite多项式的函数，Hermite多项式的定义为

$H_{n}(x)=\left\{\begin{matrix}1,n=0 & \\ 2x,n=1 & \\ 2xH_{n-1}(x)-2(n-1)H_{n-2}(x) & \end{matrix}\right.$

#include <stdio.h>

float fun(float x,int n) {
	if(n==0)
		return 1;
	else if(n==1)
		return 2*x;
	else
		return 2*x*fun(x,n-1)-2*(n-1)*fun(x,n-2);
}

2.有n个整数放在数组a中，编写递归函数，求整数之和

#include <stdio.h>

float fun(int *a, int n) {
	if(n==0)
		return a[0];
	else
		return a[n-1]+fun(a,n-1);
}

3.编写一个递归函数，计算组成给定正整数n的所有数字之和

#include <stdio.h>

float fun(int n) {
	if(n<10)
		return n;
	else
		return n%10+fun(n/10);
}

4.设函数f(n)是如下递归定义的：

f(0)=0

f(1)=1

f(2)=2

f(n+2)=f(n-1)+f(n+1) (当n>=1)

#include <stdio.h>

float fun(int n) {
	if(n==0)
		return 0;
	else if(n==1)
		return 1;
	else if(n==2)
		return 2;
	else
		return fun(n-3)+fun(n-1);
}

5.假设有函数定义（下面n为自然数）

f(n)=n (当0<=n<=5)

f(n)=f(n-1)-f(n-3)-f(n-5) (当n>=6)

#include <stdio.h>

float fun(int n) {
	if(n<=5&&n>=0)
		return n;
	else
		return fun(n-1)-fun(n-3)-fun(n-5);
}

6.利用递归方法求5！

#include <stdio.h>

float fun(int n) {
	if(n==0)
		return 1;
	else
		return n*fun(n-1);
}

int main() {
	printf("%f",fun(3));
}

7.利用函数调用方式，将所输入的5个字符，以相反顺序打印出来

#include <stdio.h>

void fun(char *str, int n) {
	for(int i=n-1; i!=-1; i--)
		printf("%c",str[i]);
}

int main() {
	char str[5];
	scanf("%s",str);
	fun(str,5);
}

8.一个长度为n（double类型变量，n>5）的木条，可以在其2/5处这段，变成两段长度分别为2n/5，3n/5的木条，如果得到的木条长度仍大于5，则继续按照上述方法折断，直到任意木条的长度均不大于5为止。编写递归函数，计算一个长度为n的木条，最后会被折断为多少根木条

#include <stdio.h>

int fun(int n) {
	if(n<=5)
		return 1;
	else
		return fun(2*n/5)+fun(3*n/5);
}

9.提供给定一个凸n边形（n>=3）,可以用n-3条不相交的对角线把他剖分称n-2个三角形，编写递归函数，计算递归函数，计算凸n边形的三角形剖分数（不同剖分方法的个数）。提示：递归公式如下：

$f(n)=\left\{\begin{matrix} 1,n=2\\ \sum_{i=2}^{n-1}\begin{Bmatrix} f(i)*f(n+1-i) \end{Bmatrix},n>=3 \end{matrix}\right.$

#include <stdio.h>

int fun(int n) {
	int sum=0;
	if(n==2)
		return 1;
	else
		for(int i=2; i<n; i++)
			sum+=fun(i)*fun(n+1-i);
	return sum;
}

10.给定一个正整数n，将其拆分为n个1.可行的拆分过程为：（设定一个初值为0的累加器）首先，将n拆分为2个数，二者之和为n，二者之差的绝对值加入累加器中；再对拆分得到的2个数分别进行上述”拆分+累加“操作，直到所有的数均拆分为1为止。编写递归程序，计算所有可行拆分过程所对应累加器的最小值，提示：递归公式如下：

$f(n)=\left\{\begin{matrix} 0,n=1\\ min_{i=1,...n/2}(n-i)-i,+f(i)+f(n-i),n>=2 \end{matrix}\right.$

#include <stdio.h>

int fun(int n) {
	int min=fun(n-1)+n-2;
	if(n==1)
		return 0;
	else
		for(int i=1; i<=n/2; i++) {
			int flag=n-i-i+fun(i)+fun(n-1);
			if(min>flag)
				min=flag;
		}
	return min;
}

11.编写递归函数float comp(float a[][2],int n)，计算两个给定的n维向量u，v的内积。A的每一行为一个向量；函数值为计算出的内积

#include <stdio.h>

float comp(float a[][2],int n) {
	if(n==0)
		return 0;
	return comp(a,n-1)+a[n-1][0]*a[n-1][1];
}

12.编写递归函数，求两个数x和y的最大公约数。公式递归定义如下：

$gcd(x,y)=\left\{\begin{matrix} x,y=0 & \\ gcd(y,x\%y),y!=0& \end{matrix}\right.$

#include <stdio.h>

int gcd(int x,int y) {
	if(y==0)
		return x;
	return gcd(y,x%y);
}

13.编写递归函数，求任意正整数n从右边开始的第j为数字（默认：最右侧为第一位），公式递归定义如下：

$digit(n,j)=\left\{\begin{matrix} n\%10,j=1 & \\ digit(n/10,j-1),j>1 & \end{matrix}\right.$

#include <stdio.h>

int digit(int n,int j) {
	if(j==1)
		return n%10;
	else
		return digit(n/10,j-1);
}

14.编写递归函数，实现按照如下公式计算的功能

//提示：如果独立编写阶乘运算函数，可以不考虑存储溢出，默认结果类型为整型

f(n)=0/(1*2!)+1/(2*3!)+2/(3*4!)+3/(4*5!)+...+n/((n+1)*(n+2)!),其中：n为自然数

#include <stdio.h>

int fac(int n) {
	if(n==0)
		return 1;
	else
		return n*fac(n-1);
}

int digit(int n) {
	if(n==0)
		return 0;
	else
		return digit(n-1)+n*1.0/((n+1)*fac(n-2));
}

15.写一个递归函数，实现对有序数组的二分法检索（折半查找）

#include <stdio.h>

int search(int *a,int low,int high,int key) {
	if(low<high) {
		int middle = (high+low)/2;
		if(a[middle]=key)
			return middle;
		else {
			if(key<a[middle])
				high=middle-1;
			else
				low=middle+1;
			search(a,low,high,key);
		}
	} else
		return -1;
}

16.用n*n的矩阵a表示有向图的邻接表，其中若节点i到节点j有边，则a[i,j]=1，若节点i到节点j无边，则a[i,j]=0，编写函数，给定节点i和步长k，计算节点i经k步能到达的所有节点

#include <stdio.h>

int a[5][5]= {0,1,0,1,0,
              1,0,1,0,1,
              0,1,0,1,1,
              1,0,1,0,0,
              0,1,1,0,0
             };
int flag[5] = {0};

void dfs(int a[][5],int v,int k,int *path,int i) {
	path[i]=v;
	flag[v]=1;
	if(i==k) {
		for(int i=0; i<=k; i++)
			printf("%d ",path[i]+1);
		flag[v]=0;
		printf("\n");
	}
	for(int j=0; j<5; j++)
		if(a[v][j]!=0&&flag[j]==0)
			dfs(a,j,k,path,i+1);
	flag[v]=0;
}

int main() {
	int path[5];
	dfs(a,0,2,path,0);
	return 0;
}

17.完成递归函数，实现对有序数组的二分法检索

#include <stdio.h>

int search(int *a,int low,int high,int key) {
	if(low<high) {
		int middle = (high+low)/2;
		if(a[middle]=key)
			return middle;
		else {
			if(key<a[middle])
				high=middle-1;
			else
				low=middle+1;
			search(a,low,high,key);
		}
	} else
		return -1;
}