c语言学习(三) 函数和递归

#include<stdio.h>
//写一个求两者最大值的函数
int getmax(int a, int b)
{
    return (a > b) ? a : b;
}

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

交换两个值

//交换两个数的值
void Swap(int x, int y)
{
    int t;
    t = x;
    x = y;
    y = t;
}

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

当我们输出时会发现，二者没有交换，这是为什么？？

因为这里函数用的是值传递，我们值是将a和b的值传到了函数中的x和y上，存储在不同的内存，所以我们只是修改了函数中x，y值的位置。

那我们应该怎么修改呢？

我们可以运用指针将a，b的地址传给函数，那样我们是不是因为地址不变就可以用地址来交换a，b的值了。

#include<stdio.h>
//交换两个数的值
void Swap2(int* px, int* py)//因为传的是地址，所以函数参数用指针类型接收
{
    int t;
    t = *px;
    *px = *py;
    *py = t;
}

int main()
{
    int a = 10;
    int b = 20;
    printf("%d %d\n", a, b);
    Swap(&a, &b);//我们将a，b的地址传过去
    printf("%d %d\n", a,b);
    return 0;
}

3.函数参数

3.1实际参数(实参)

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

3.2形式参数(形参)

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

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

这里我们对函数的实参和形参进行分析：

这里可以看到Swap函数在调用的时候，x，y拥有自己的空间，同时拥有了和实参一模一样的内容，所以，我哦们可以简单的认为：形参其实是实参的一份临时拷贝，对形参的修改是不会影响到实参的。

4.函数的调用：

4.1传值调用

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

4.2传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。

这种传参方式可以让函数和函数外边的变量建立起正确的联系，也就是函数内部可以直接操作函数外部的变量。

练习：

1.判断n是否为素数

#include<stdio.h>
#include<math.h>
//求素数
int is_prime(int n)
{
    for (int i = 2; i <= sqrt(n); i++)
    {
        if (n % i == 0)
            return 0;
    }
    return 1;
}

int main()
{
    int n;
    scanf("%d", &n);
    int i = is_prime(n);
    if (i == 1)
        printf("%d是素数\n", n);
    else
        printf("%d不是素数\n", n);
    return 0;
}

2.判断是否为闰年

#include<stdio.h>
#include<math.h>
//判断闰年
int is_leap_year(int n)
{
    if (n % 4 == 0 && n % 100 != 0 || n % 400 == 0)
        return 1;
    else
        return 0;
}

int main()
{
    int n;
    scanf("%d", &n);
    int i = is_leap_year(n);
    if (i == 1)
        printf("%d是闰年\n", n);
    else
        printf("%d不是闰年\n", n);
    return 0;
}

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

#include<stdio.h>
#include<math.h>
//二分查找，找到返回下标，没找到返回-1；
int binary_search(int arr[],int k)
{
    int l = 0, r = sizeof(arr) / sizeof(arr[0]) - 1;
    while (l <= r)
    {
        int mid = (l + r) / 2;
        if (arr[mid] < k)
            l = mid + 1;
        else if (arr[mid] > k)
            r = 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 ret = binary_search(arr, k);
    if (ret == -1)
        printf("找不到指定数组\n");
    else
        printf("找到了，下标是%d\n", ret);
    return 0;
}

运行完这个代码以后，你会发现，没有找到，为什么呢？

因为数组因为很大，所以他是地址传递，函数里的arr是指针，所以不能使用sizeof(arr)来求了，解决方法也简单，在main函数里求出来个数，传进函数就好了。

#include<stdio.h>
#include<math.h>
//二分查找，找到返回下标，没找到返回-1；
int binary_search(int arr[],int k,int sz)
{
    int l = 0, r = sz - 1;
    while (l <= r)
    {
        int mid = (l + r) / 2;
        if (arr[mid] < k)
            l = mid + 1;
        else if (arr[mid] > k)
            r = 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);
    if (ret == -1)
        printf("找不到指定数组\n");
    else
        printf("找到了，下标是%d\n", ret);
    return 0;
}

4.每调用一次函数，num就加1。

#include<stdio.h>
//num++
void add_num(int *num)
{
    (*num)++;
}

int main()
{
    int num = 0;
    add_num(&num);
    printf("num = %d\n", num);
    add_num(&num);
    printf("num = %d\n", num);
    add_num(&num);
    printf("num = %d\n", num);
    return 0;
}

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

函数和函数之间可以有机的组合的。

5.1嵌套调用

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

int main()
{
    three_line();
    return 0;
}

5.2链式访问

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

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[20] = "hello";
    int ret = strlen(strcat(arr, "world"));
    printf("%d\n", ret);
    return 0;
}

6.函数的声明和定义

6.1函数的声明

1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。

2.函数的声明一般出现在函数的使用之前，要满足先声明后使用。

3.函数的声明一般要放在头文件中的

6.2函数的定义

函数的定义是指函数的具体实现，交代函数的功能实现。

7.函数的递归

7.1函数递归

7.1.1什么是递归？

程序调用自身的编程技巧称为递归。递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，他通常把一个大型复杂的问题层层转化为一个与原问题相似的规则较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的主要思考方式在于，把大事化小。

7.1.2递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。

每次递归调用之后越来越接近这个限制条件。

练习1.

接受一个整形值（无符号），按照顺序打印它的每一位。

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

练习2.

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

#include<stdio.h>
int my_strlen(char* str)
{
    if (*str != '\0')
        return 1 + my_strlen(str + 1);
    else
        return 0;
}
int main()
{
    char arr[] = "hello";
    int len = my_strlen(arr); //arr是数组，数组产惨，传过去的不是整个数组，而是数组的首元素
    printf("%d\n", len);
    return 0;
}

7.2 递归与迭代

练习3.

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

#include<stdio.h>
int factor(int n)
{
    if (n <= 1)
        return 1;
    else
        return n * factor(n - 1);
}
int main()
{
    int n;
    scanf("%d", &n);
    int ret = factor(n);
    printf("%d\n", ret);
    return 0;
}

练习4.

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

//斐波那契 1 1 2 3 5 8 13 21 34 55 ... 
#include<stdio.h>
int fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    int ret = fib(n);
    printf("%d\n", ret);
    return 0;
}

但是我们发现有问题

在使用fib这个函数的时候如果我们要计算第50给斐波那契数字的时候特别耗费时间。

使用factor函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

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

#include<stdio.h>
int count = 0;
int fib(int n)
{
    if (n == 3)
        count++;
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    int ret = fib(n);
    printf("ret = %d\n", ret);
    printf("count = %d", count);
    return 0;
}

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

那我们如何改进呢？

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

那如何解决上述问题？

1.将递归改写成非递归。

#include<stdio.h>
int fib(int n)
{
    int a = 1, b = 1, c = 1;
    while (n > 2)
    {
        c = a + b;
        a = b;
        b = c;
        n--;
    }
    return c;
}
int main()
{
    int n;
    scanf("%d", &n);
    int ret = fib(n);
    printf("ret = %d\n", ret);
    return 0;
}

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

提示：

1.许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。

2.但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差点。

3.当一个问题相当赋值，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。