3.23c语言笔记--函数

int Add(int x,inty)
{
    return x+y;
}



int main()
{
    int a=10,b=20;
    int sum = Add(a,b);
    printf("%d",sum);
    return 0;
}

strcpy()函数

复制字符串--\0也被复制过去

 memset（void * ptr,int value,size_t num）;

int main()
{     
    char arr[]="hello world";
    memset(arr,'*',5);//替换5个字符为*
    printf("%s\n",arr);
}

自定义函数的使用

自定义函数和库函数一样，有函数名和参数和返回值

  例如创建一个函数比较两个数的大小

int get_max(int x,int y)
{    
    if(x<y)
return y;
else
return x;
}



int main()
{
    int a=10 ,b=20;
    int max=get_max(a,b);
    printf("max = %d\n",max);
return 0;
}

 写一个函数交换两个变量的值

void swap(int x,int y)
{
  int t=0;
  t=x;
  x=y;
  y=t;
}


int main()
{
    int a=10;
    int b=20;
    swap(a,b);
printf("%d",a,b);
return 0;
}

但以上的代码并不能交换a，b的值，形参x，y的地址和实参a，b的地址不一样

实参的传递是单向的，形参函数无返回值所以，只交换了x，y的地址，实参a，b不变

运用指针变量来实现a，b的交换

void swap(int* pa,int *pb)
{
    int t=0;
    t = *pa;
    *pa = *pb;
    *pb = t;
    
}

int main()
{
    int a=10;
    int b=20;
printf("a=%d b=%d\n",a,b);
    swap(&a,&b);
printf("a=%d b=%d",a,b);
return 0;
}

代码段把实参a，b的地址传递到形参pa，pb，*pa，*pb就找到对应地址的值

实参和形参

 

函数的调用

 

用函数调用的方法输出100-200中的素数

int is_prime(int n)
{
	int j = 0;
	for (j = 2; j < n; j++)
	{
		if (n % j == 0)break;
	}
	if (n == j)return 1;
}



int main()
{
	int i;
	for (i = 100; i <= 200; i++)
	{
		if (is_prime(i) == 1)
			printf("%d ", i);
	}
	return 0;
}

用函数判断是否为闰年

int is_leap_year(int y)
{
    if((y%4==0&&y%4!=0||y%400==0))
    return 1;
    else
    return 0;
}

int main()
{   int year;
    for(year=1000;year<=2000;year++)
    {
        if(is_leap_year(year)==1)
            printf("%d",year);
    }
    return 0;
}

用函数实现二分查找

int binary_search(int arr[],int k，int sz)//这里的arr是一个指针
{   /*int sz = sizeof(arr)/sizeof(arr[0]);不能计算出元素个数*/
    int left =0;
    int right = sz-1;
    
while(left<=right)
{    
     int mid = (left+riht)/2;
     if(arr[mid]<k)
    {
        left=mid+1;
    }
    else if(arr[mid]>k)
    {    
        riht=mid-1;
    }
    else
        return mid
}
 return -1;
}


int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int k=7;
    int sz = sizeof(arr)/sizeof(arr[0]);
    int ret = binary_search(arr,k，sz);//传递的arr[0]的地址
    if(ret==-1)
    {
        printf("找不到指定的数字\n");
    else
        {
           printf("找到了下标是：%d"，ret);
        }
    }
    return 0;
}

每调用一次函数使num+1

void Add(int* p)
{
    (*p)++;
}

int main()
{
    int num=0;
 Add(&num)；
    printf("%d",num);
 Add(&num)；
    printf("%d",num);
 Add(&num)；
    printf("%d",num);
return 0;
}

函数的嵌套调用

链式访问

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

函数的声明

int Add(int x,int y)

int main(){.....}

 

函数递归

 

 

用函数求字符串的长度

#include<string.h>


int my_len(char* arr)
{
    int count=0,str;
while(*str!='\n')
    {
        count++;
        str++;
    }
    return count;
}


int main()
{
    char arr[]="bit";
int len =my_strlen(arr);
printf("len=%d",len);
}

递归思想实现

#include <string.h>

int my_strlen(char* str)
{
    if(*str!=0)
    return 1+my_strlen(str+1);//当层层调用后，if不再满足，则停下来，这时候函数向上层层递归
    else
    return 0;
}

int main()
{
    char arr[]="bit";
    int len=my_strlen(arr);
    printf("len=%d",len);
}

向下传递，向上递归

斐波那契数

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;
    int ret =0;
    scanf("%d",&n);
    ret = Fib(n);
    printf("%d",ret);
return 0;
}

汉诺塔递归

#include<stdio.h>
#include<stdlib.h>
#define MAX_LEVEL 30	//设置最大层数

int steps = 0;//steps保存盘子移动次数
void move(int pile, char src, char tmp, char dst);

int main(void)
{
	int levels = 0;
	printf("输入汉诺塔层数（1~%d）：", MAX_LEVEL);
	scanf("%d", &levels);
	if (levels > 0 && levels < 30)//判断是否符合层数范围
	{
		move(levels, 'A', 'B', 'C');
		printf("共移动了%d次。\n", steps);
		system("pause");
		return 0;
	}
	printf("输入范围错误\n");
	system("pause");
	return 1;

}

void move(int pile, char src, char tmp, char dst)
{
	if (pile == 1)//pile=1问题就好解决了
	{
		printf("%c --> %c\n", src, dst);
		steps++;
		return;
	}
	move(pile - 1, src, dst, tmp);
	move(1, src, tmp, dst);
	move(pile - 1, tmp, src, dst);
}

1. 把n-1层盘子从起点移到暂存区A->C->B
2. 然后把第n层盘子从起点移到终点A->B->C
3. 然后把n-1层盘子从暂存区移到终点B->A->C

青蛙跳台阶问题

青蛙跳台阶问题本质上就是斐波那契数列问题。因此，我们遇到新问题时要联想到以前的解决方法。

有的问题既可以用循环实现，也可以用递归来实现。递归更容易被我们想到，但有时递归代码的效率会不如循环代码。因此，要根据具体情况选择合适的方法。

用递归实现

#include <stdio.h>
int Fn(int n) {
    if (n <= 2) {
        return n;
    }
    else if (n > 2) {
        return Fn(n - 1) + Fn(n - 2);
    }
}
int main() {
    int n = 0;
    printf("请输入台阶数：");
    scanf("%d", &n);
    printf("共有%d种跳法\n", Fn(n));
    return 0;
 }

用循环实现

#include <stdio.h>
int Fn(int n) {
    int a = 1;
    int b = 2;
    int c = 0;
    if (n == 1) {
        return 1;
    }
    else if (n == 2) {
        return 2;
    }
    else {
        for (int i = 3;i <= n;i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}
int main() {
    int n = 0;
    printf("请输入台阶数：");
    scanf("%d", &n);
    printf("共有%d种跳法\n", Fn(n));
    return 0;
}