C语言(函数的形参，实参，递归，迭代)

#include
#define _CRT_SECURE_NO_WARNINGS 
#include
#include"add.h"

                                                 Q1: 计算两点欧几里得距离的函数:

#include
#include
double dist(double x1, double x2, double y1, double y2)
{
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

int main()
{
    double x1 = 3.2;
    double x2 = 5.5;
    double y1 = 4.5;
    double y2 = 7.5;
    double dis=dist(x1, x2, y1, y2);
    printf("dist=%lfn", dis);
    return 0;
}

C语言中的函数可定义为"返回类型 函数名（参数列表｛函数体｝），其中函数体的最后一条语句应该是return表达式"
有时，函数并不需要返回任何值，例如，它只是用printf向屏幕输出一些内容。这时只需定义函数返回类型为void，并且无须使用return（除非希望在函数运行中退出函数）。

                                               Q2:用函数交换变量的值（错误)

#include
void exc(int x,int y)
{
    int t = x;
    x = y;
    y = t;
}
int main()
{
    int a = 10;
    int b = 20;
    printf("交换前，a=%d,b=%d", a, b);
    exc(a, b);
    printf("交换后，a=%d,b=%d", a, b);
    return 0;
}

                                        Q3:用函数交换变量的值（正确，用指针做参数)

#include
void exc(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
}
int main()
{
    int a = 10;
    int b = 20;
    printf("交换前，a=%d,b=%d", a, b);
    exc(&a, &b);
    printf("交换后，a=%d,b=%d", a, b);
    return 0;
}

函数递归:大事化小，函数自己调用自己。
 程序调用自身的编程技巧成为递归，递归作为一种算法在程序设计中广泛应用。一个过程或函数在其定义域说明中有直接间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略。只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

void print(unsigned int n)
{
    if (n > 9)
    {
        print(n / 10);
    }
    printf("%d ", n % 10);
}

int main()
{
 //接受一个整型值（无符号），按照顺序打印它的每一位
    unsigned int num = 0;
    scanf_s("%d", &num);//1234
    print(num);
    return 0;
}

编写函数，不允许创建临时变量，求字符串的长度
int my_strlen(char *s)
{
    int count = 0;
    while (*s != '')
    {
        s++;
        count++;
    }
    return count;
}
int main()
{
    char arr[10] = "abcdef";
    int len = my_strlen(arr);
    printf("count=%d", len);
    return 0;
}

创建了临时变量，递归解决一下:大事化小
my_strlen("abcd")
1+my_strlen("bcd")
1+1+my_strlen("cd")
1+1+1+my_strlen("d")
1+1+1+1+my_strlen("")
1+1+1+1+0=4

int my_strlen(char *s)
{
    if (*s != 0)
    {
        return 1 + my_strlen(1 + s);
    }
    else
    {
        return 0;
    }
}
int main()
{
    char arr[10] = "abcdef";
    int len = my_strlen(arr);
    printf("count=%d", len);
    return 0;
}

字符指针+1 - 向后跳1个字节
char *p;
p+1 -> 向后跳一个字节
整形指针+1,向后跳4个字节
int *p;
p+1 -->向后跳4个字节
指针+1都是指向下一个元素的位置，元素占多少字节，则跳过多少。

                                                        Q4:利用函数的递归和迭代求n！

#include
int fuc(int n)
{
    if (n > 1)
    {
        return fuc(n - 1) * n;
    }
    else
    {
        return 1;
    }
    
}
int main()
{
    int n = 0;
    scanf_s("%d", &n);
    int ret=fuc(n);
    printf("%d", ret);
    return 0;
}

                                                          Q5:求第n个斐波那契数

int count = 0;
int Fib1(int n)
{
    if (n == 3)
    {
        count++;
    }
    if (n > 2)
    {
        return Fib1(n - 1) + Fib1(n - 2);
    }
    else
        return 1;
}
int main()
{
    int n = 0;
    scanf_s("%d", &n);
    int ret = Fib1(n);
    printf("%dn", ret);//斐波那契数值；
    printf("%dn", count);//第3个斐波那契数计算的次数；
    return 0;
}

                                        Q6:另一种高效的斐波那契数求法(非递归，迭代)

int Fib2(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_s("%d", &n);
    int ret = Fib2(n);
    printf("%dn", ret);//斐波那契数值；
    return 0;
}

什么时候用递归：
1.当解决一个问题递归和非递归都可以使用，且没有明显问题。那就可以使用递归。
2.当解决一个问题递归写起来很简单，非递归比较复杂，且递归没有明显问题，那就用递归。
3.用递归解决问题写起来简单但是有明显问题，就不能使用。