初识C语言-函数-习题参考

练习1：

1. 写一个函数可以判断一个数是不是素数。

#include <stdio.h>
#include <math.h>

int IsPrime(int n);

int main()
{
	int n;
	scanf("%d", &n);
	if (IsPrime(n))
		printf("是素数！");
	else
		printf("不是素数！");
	return 0;
}

int IsPrime(int n)
{
	for (int i = 2; i < sqrt(n); i++)//这里为什么是sqrt（n）呢？同学们可以查询资料学习一下！
	{
		if (0 == n % i)
			return 0;
	}
	return 1;
}

3. 写一个函数判断一年是不是闰年。

#include <stdio.h>

int IsRun(int n);

int main()
{
	int n;
	scanf("%d", &n);
	if (IsRun(n))
		printf("是闰年！");
	else
		printf("不是闰年！");
	return 0;
}

int IsRun(int n)
{
	if (((0 == n % 4) && (0 != n % 100)) || (0 == n % 400))
		return 1;
	else
		return 0;
}

5. 写一个函数，实现一个整形有序数组的二分查找。

#include <stdio.h>

void ErFeng(int a[], int sz, int n);

int main()
{
	int a[] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(a) / sizeof(a[0]);
	int n;
	scanf("%d", &n);
	ErFeng(a, sz, n);
	return 0;
}

void ErFeng(int a[], int sz, int n)
{
	int left = 0;
	int right = sz;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (n < a[mid])
			right = mid - 1;
		else if (n > a[mid])
			left = mid + 1;
		else
		{
			printf("找到啦！下标是：%d", mid);
			break;
		}
	}
	if (left > right)
		printf("没找到！");
}

7. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。

#include <stdio.h>

int num = 0;

void test(void);

int main()
{
	int n;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		test();
	}

	printf("%d", num);

	return 0;
}

void test(void)
{
	num++;
}

练习2：

1、接受一个整形值（无符号），按照顺序打印它的每一位
例如：
输入：1234
输出：1 2 3 4

#include <stdio.h>

void f(int n);

int main()
{
	int n;
	scanf("%d", &n);
	f(n);
	return 0;
}

void f(int n)
{
	if (0 != n / 10)
	{
		f(n / 10);
	}
	printf("%d ", n % 10);
}

2、编写函数不允许创建临时变量，求字符串长度

#include <stdio.h>

int my_strlen(char s[]);

int main()
{
	char s[] = "abcdef";
	int ret = my_strlen(s);
	printf("%d", ret);
	return 0;
}

int my_strlen(const char s[])
{
	if ('\0' != *s)
		return 1 + my_strlen(s + 1);
	else
		return 0;
}

3、求n的阶乘（不考虑溢出）

#include <stdio.h>

long long int factorial(int n);

int main()
{
	int n;
	scanf("%d", &n);
	long long int ret = factorial(n);
	printf("%lld", ret);
	return 0;
}

long long int factorial(int n)
{
	if (1 == n)
		return 1;
	else
		return n * factorial(n - 1);
}

4、求第n个斐波那契数（不考虑溢出）

#include <stdio.h>

int fib(int n);

int main()
{
	int n;
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d", ret);
	return 0;
}

int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

但是我们发现有问题：
在使用fib这个函数的时候如果我们计算第50个斐波那契数字的时候特别耗费时间。
使用factorial函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

我们发现fib函数在调用过程中很多计算其实一直重复。
如果我们把代码修改一下：

//4、求第n个斐波那契数（不考虑溢出）
#include <stdio.h>

int fib(int n);

int count = 0;

int main()
{
	int n;
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d", ret);
	return 0;
}

int fib(int n)
{
	count++;
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

最后我们输出看看count，是一个很大很大的值。

那我们如何改进呢？

在调试factorial函数的时候，如果你的参数比较大，那就会报错：stack overflow（栈溢出）这样的信息。
系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者死递归，这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

那如何解决上述的问题？

1、将递归改写成非递归
2、使用static对象代替nonstatic局部对象。在递归函数设计中，可以使用static对象替代nonstatic局部对象（即栈对象），这部仅仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层访问。

比如，下面代码就改用了非递归的方式来实现：

//求n的阶乘
int factorial(int n)
{
        int result = 1;
        while (n > 1)
       {
             result *= n ;
             n -= 1;
       }
        return result;
}
//求第n个斐波那契数
int fib(int n)
{
     int result;
     int pre_result;
     int next_older_result;
     result = pre_result = 1; 
     while (n > 2)
     {
           n -= 1;
           next_older_result = pre_result;
           pre_result = result;
           result = pre_result + next_older_result;
     }
     return result;
}

提示：

1、许多问题是以递归形式进行解释的，这只是因为它比非递归的形式更为清晰。
2、但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3、当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。