函数就是子程序
为什么会有库函数?
所有更加重要的是自定义函数。
自定义函数和库函数一样,有函数名,返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
函数的组成:
ret_type fun_name(para1, * )
{
statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数
创造求较大值函数get_max(int x,int y):
#include
int get_max(int x, int y)
{
return(x > y ? x : y);
}
int main()
{
int a = 0;
int b = 0;
scanf("%d%d", &a, &b);
//求最大值
int max = get_max(a, b);
printf("max = %d\n", max);
return 0;
}
写一个函数可以交换两个整形变量的内容。
#include
void Swap(int x, int y)
{
int z = 0;
z = x;
x = y;
y = z;
}
int main()
{
int a = 10;
int b = 20;
printf("交换前:a=%d b=%d\n", a, b);
//函数
Swap(a, b);
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
很多人会这样写,但是会达不到效果,看一下运行结果吧
发现a和b的值并没有交换,为什呢?
那我们就传实参的地址给形参
#include
void Swap(int* px, int* py)
{
int z = 0;
z = *px;
*px = *py;
*py = z;
}
int main()
{
int a = 10;
int b = 20;
printf("交换前:a=%d b=%d\n", a, b);
//函数
Swap(&a, &b);
printf("交换后:a=%d b=%d\n", a, b);
return 0;
}
函数的形参和实参分别占有不同内存块,对形参的修改不会影响实参。
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起真正的联系,也就是函数内部可以直接操作函数外部的变量。
//1. 写一个函数可以判断一个数是不是素数。
#include
#include
int is_prime(int n)
{
//试除法
//2--n-1
//2--sqrt(n)
int j = 0;
for (j = 2; j <= sqrt(n); j++)
{
if (n % j == 0)
return 0;
}
return 1;
}
int main()
{
//100--200之间的素数
int i = 0;
for (i = 100; i <= 200; i++)
{
//判断是否为素数
if (is_prime(i) == 1)
{
printf("%d ", i);
}
}
return 0;
}
2. 写一个函数判断一年是不是闰年。
写一个函数is_leap_year(int n)判断n是否为闰年,是闰年返回1,不是闰年返回0;根据返回结果打印闰年
#include
int is_leap_year(int year)
{
if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0))
{
return 1;
}
else
{
return 0;
}
}
int main()
{
//1000--2000之间的闰年
int y = 0;
for (y = 1000; y <= 2000; y++)
{
//判断是否为闰年
//如果是闰年,返回1
//不是闰年,返回0
if (is_leap_year(y) == 1)
{
printf("%d ", y);
}
}
return 0;
}
3. 写一个函数,实现一个整形有序数组的二分查找。
写查找函数int binary_search(int arr[],int n, int size)
查找k=7,找到了返回下标,找不到返回-1
第一种写法:
//3. 写一个函数,实现一个整形有序数组的二分查找。
#include
int binary_search(int arr[],int n, int size)
{
int left = 0;
int right = size - 1;
while (left <= right)
{
int mid = (left + right) / 2;
if (n < arr[mid])
right = mid - 1;
else if (n > arr[mid])
left = mid + 1;
else
return mid;
}
return -1;
}
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10 };
int k = 7;
//计算数组元素的个数
int sz = sizeof(arr) / sizeof(int);
//找到了返回下标
//找不到返回-1
int ret = binary_search(arr, k, sz);//测试驱动开发
if (ret == -1)
printf("找不到\n");
else
printf("找到了,下标是:%d\n",ret);
return 0;
}
第二种写法:
#include
int binary_search(int arr[], int n, int left,int right)
{
while (left <= right)
{
int mid = (left + right) / 2;
if (n < arr[mid])
right = mid - 1;
else if (n > arr[mid])
left = mid + 1;
else
return mid;
}
return -1;
}
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10 };
int k = 3;
//计算数组元素的个数
int sz = sizeof(arr) / sizeof(int);
//找到了返回下标
//找不到返回-1
int ret = binary_search(arr, k, 0, 9);//测试驱动开发
if (ret == -1)
printf("找不到\n");
else
printf("找到了,下标是:%d\n", ret);
return 0;
}
#include
void Add(int* p)
{
*p = *p + 1;
}
int main()
{
int num = 0;
Add(&num);
printf("%d\n", num);//1
Add(&num);
printf("%d\n", num);//2
Add(&num);
printf("%d\n", num);//3
return 0;
}
#include
int Add(int n)
{
return n + 1;
}
int main()
{
int num = 0;
num = Add(num);
printf("%d\n", num);//1
num = Add(num);;
printf("%d\n", num);//2
num = Add(num);
printf("%d\n", num);//3
return 0;
}
函数和函数之间可以有机的组合的。
#include
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;
}
函数可以嵌套调用,但是不能嵌套定义。
把一个函数的返回值作为另外一个函数的参数。
#include
#include
int main()
{
char arr[20] = "hello";
int ret = strlen(strcat(arr, "bit"));//这里介绍一下strlen函数
printf("%d\n", ret);
return 0;
}
#include
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
//结果是啥?
//注:printf函数的返回值是打印在屏幕上字符的个数
return 0;
}
printf返回在屏幕打印字符的个数,
printf("%d", printf("%d", printf("%d", 43)));
printf("%d", printf("%d", 2));
printf("%d", 1)
函数的定义是指函数的具体实现,交待函数的功能实现
//test.h的内容
//放置函数的声明
#ifndef __TEST_H__
#define __TEST_H__
//函数的声明
int Add(int x, int y);
#endif //__TEST_H__
//test.c的内容
//放置函数的实现
#include "test.h"
//函数Add的实现
int Add(int x, int y)
{
return x+y;
}
程序调用自身的编程技巧称为递归( recursion)。
递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。
递归的主要思考方式在于:把大事化小
接受一个整型值(无符号),按照顺序打印它的每一位。
例如:
输入:1234,输出 1 2 3 4.
参考代码:
#include
void print(int n) {
if(n>9)
{
print(n/10);
}
printf("%d ", n%10);
}
int main()
{
int num = 1234;
print(num);
return 0;
}
编写函数不允许创建临时变量,求字符串的长度。
参考代码:
//递归求字符串长度
#include
int my_strlen(char* s)
{
if (*s != '\0')
{
return 1 + my_strlen(s + 1);
}
else
{
return 0;
}
}
int main() {
//求字符串长度
char arr[10] = "abcdef";
//数组名是数组首元素地址
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
求n的阶乘。(不考虑溢出)
#include
//int Fac(int n)//非递归
//{
// int i = 0;
// int ret = 1;
// for (i = 1; i <= n; i++)
// {
// ret *= i;
// }
// return ret;
//}
int Fac(int n)//递归
{
if (n <= 1)
return 1;
else
return n * Fac(n - 1);
}
int main()
{
//求阶乘
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d", ret);
return 0;
}
求第n个斐波那契数。(不考虑溢出)
参考代码:
//求第n个斐波那契数。(不考虑溢出)
//1 1 2 3 5 8 13 21 34 55
//前两个数字之和为第三个数字
//Fib(int n)
//n<=2, 1
//n>2, Fib(n-1)+Fib(n-2)
//递归
#include
int Fib(int n)
{
if (n <= 2)
return 1;
else
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("%d ", ret);
}
但是,用递归方法不合适,我们发现 fib 函数在调用的过程中很多计算其实在一直重复。
非递归效率提升很多:
#include
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while (n > 2)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("%d", ret);
return 0;
}
//汉诺塔问题
//假设总共需要移动n个盘子
//1.将A柱上的n - 1个盘子借助C柱移向B柱
//2.将A柱上仅剩的最后一个盘子移向C柱
//3.将B柱上的n - 1个盘子借助A柱移向C柱
#include
void move(int x, int y)
{
printf("%c->%c\n", x, y);
}
void hanoi(int n, char a, char b, char c)
{
if (n == 1)
{
move(a, c);
}
else
{
hanoi(n - 1, a, c, b);//将A座上的n-1个盘子借助C座移向B座
move(a, c);//将A座上最后一个盘子移向C座
hanoi(n - 1, b, a, c);//将B座上的n-1个盘子借助A座移向C座
}
}
//move中的实参与hanoi函数中的形参相对应,而hanoi函数中形参a,b,c所对应的值也是在有规律的变化
int main()
{
int n = 0;
scanf("%d", &n);
hanoi(n, 'A', 'B', 'C');
return 0;
}
2. 青蛙跳台阶问题
一只青蛙一次可以跳上 1 级台阶,也可以跳上2 级。求该青蛙跳上一个n 级的台阶总共有多少种跳法。
分析:当n = 1, 只有1中跳法;当n = 2时,有两种跳法;当n = 3 时,有3种跳法;当n = 4时,有5种跳法;当n = 5时,有8种跳法;…
从第三个起,每个数字是前两个数字之和,类似于规律Fibonacci数列:
#include
int Fib(int n)
{
if (n <= 0)
{
printf("error");
return -1;
}
if (1 == n)
{
return 1;
}
else if (2 == n)
{
return 2;
}
else
{
return Fib(n - 1) + Fib(n - 2);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("一共有%d 种跳发\n", ret);
return 0;
}
1.当解决一个问题递归和非递归都可以使用,且没有明显问题,那就可以使用递归
2.当问题用递归简单二非递归较难且递归没有明显问题,那就可以用递归
3.如果说用递归解决问题,写起来简单,但是有明显问题,就不能用递归,应该用非递归的方式解决问题