函数与递归

1.函数是什么

定义：子程序，是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软
件库。

2.库函数

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

学习库函数的网站：www.cplusplus.com

例如

strcpy

char * strcpy ( char * destination, const char * source );

memset

void * memset ( void * ptr, int value, size_t num );

注意：使用库函数，必须包含 #include 对应的头文件。

3.自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。 但是不一样的是这些都是我们自己来设计。

写一个函数可以找出两个整数中的最大值。

//写一个函数可以找出两个整数中的最大值。
#include <stdio.h>
int get_max(int x,int y)
{
	return (x > y) ? (x) : (y);
}
int main()
{
	int num1 = 10;
	int num2 = 20;
	int max = get_max(num1, num2);
	printf("max=%d\n", max);
	return 0;
}

写一个函数可以交换两个整型变量的内容：

#include<stdio.h>
	void swap1(int x, int y)
	{
		int tmp = 0;
		tmp = x;
		x = y;
		y = tmp;
}

	void swap2(int* px, int* py)
	{
		int tmp = 0;
		tmp = *px;
		*px = *py;
		*py = tmp;
	}
	int main()
	{
		int num1 = 1;
		int num2 = 2;
		swap1(num1, num2);
		printf("swap1::num1=%d num2=%d", num1, num2);
		swap2(&num1, &num2);
		printf("swap2::num1=%d num2=%d", num1, num2);
		return 0;
}

 运行结果如下：

 为什么会出现不同的结果？

其实是传参的问题

先解释两个名词 ：

实参：真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形参：形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

上面Swap1和Swap2函数中的参数 x，y，px，py 都是形式参数。在main函数中传给Swap1的num1，num2和传给Swap2函数的&num1，&num2是实际参数。

当实参传递给形参的时候，形参是实参的一份临时拷贝，所以对形参的修改不会影响实参.

形参会重新创建一个新的内存空间 

那么其实引出下面关于函数的调用

4.函数的调用

1.传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

swap1属于该类

2.传址调用

1.传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
2.这种传参方式可以让函数和函数外边的变量建立起正真的联系，也就是函数内部可以直接操
作函数外部的变量。

练习：

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

#include <stdio.h>
#include <math.h>
int is_prime(int n)
{
	for (int j = 2; j < sqrt(n); j++)
	{
		if (n % j == 0)
			return 0;
		else
			return 1;
	}
}
int main()
{
	int x;
	scanf("%d", &x);
	if (is_prime(x) == 1)
		printf("是");
	else
		printf("不是");
	return 0;
}

2. 写一个函数筛选1000-2000的闰年。

#include <stdio.h>
int is_leap_year(int y)
{
	return ((y % 4 == 0) && (y % 100 != 0 ))||( y % 400 == 0);
}
int main()
{
	for (int j = 1000;j <= 2000; j++)
	{
		if (is_leap_year(j) == 1)
		{
			printf("%d\n", j);
		}
	}
	return 0;
}

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

#include <stdio.h>
int binary_search(int arr[], int k, int sz)
{
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;//找不到
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	scanf("%d", &k);
	int ret=binary_search(arr, k, sz);
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是%d\n", ret);

	}
	return 0;
}

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

#include <stdio.h>
void test(int* p)
{
	*p = *p + 1;
}
int main()
{
	int num = 0;
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	return 0;
}

5.函数的嵌套调用和链式访问

嵌套调用

#include <stdio.h>
void new_line()
{
	printf("hehe\n");
}
void three_line()
{
  int i = 0;
for (i = 0; i < 3; i++)
 {
	new_line();
 }
}
int main()
{
	three_line();
	return 0;
}

链式访问

把一个函数的返回值作为另外一个函数的参数

int main()
{
  char arr[20] = "hello";
int ret = strlen(strcat(arr,"bit"));
printf("%d\n", ret);
return 0;
}

7.函数的声明与定义

函数声明：
1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关
紧要。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。
函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。

可将源文件设为静态库从而保护源码。

8.函数递归

递归的两个必要条件
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

练习1

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

#include <stdio.h>
void print(int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	int num = 1234;
	print(num);
	return 0;
}

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

#incude <stdio.h>
int Strlen(const char* str)

{
	if (*str == '\0')
		return 0;
	else return 1 + Strlen(str + 1);
}
int main()
{
	char* p = "abcdef";
	int len = Strlen(p);
	printf("%d\n", len);
	return 0;
}

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

直接从数学公式进行分析

fac(n） n<=1

           n>1  n*fac(n-1)

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

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

按照上述方法写出如下代码

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

 但是有些问题：

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

所以选择用迭代

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. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开
销。