#include<stdio.h>
int main()
{
    printf("hehe");
    main();//陷入死循環(huán)，但因為棧溢出，最后會停下來 == stack overflow - 棧溢出

 任何一次函數調用，它都會向內存申請空間，分為三部分 棧區(qū)，堆區(qū)，靜態(tài)區(qū)

 棧區(qū) ：局部變量，函數的形參

堆區(qū)： 動態(tài)開辟的內存 - malloc（分配內存） and calloc（動態(tài)內存分配并初始化零）

 靜態(tài)區(qū)： 全局變量，static修飾的變量
    return 0;
}

#include<stdio.h>
一共調用三次 
1                                                    2                                    3
void print(int n)// n == 123                       void print(int n）n == 12         void print(int n）  m == 1 
{                                           //    {                                 {                                             
    if (n > 9)                             //         if (n > 9)                        if (n > 9)         
    {                                       //        {                                {                                       
        print(n / 10);// 這里再調用 print 函數            print(n / 10);                  print(n / 10);            
    }                                      //         }                                }
    printf("%d ",n%10);   // 最后打印3  //           printf("%d ",n%10); 再打印個2      printf("%d ",n%10); 首先打印 1
}                                          //     }                                 }   
int main()
{
    unsigned int num = 0;
    scanf("%d",&num);//123
    //遞歸
    print(num);//1 2 3 
    return 0;
}

#include<stdio.h>
#include<string.h>

寫法1（計數器）
int my_strlen(char* str)//str指針變量,需要返回整形
{
    int count = 0;   
    while (*str != '\0')
    {
        count++;
        str ++;
    }
    return count;
}
寫法2（遞歸）
int my_strlen(char* str)//str指針變量,需要返回整形
{
    if (*str != '\0')
    {
        return 1 + my_strlen(str + 1);
    }
    else
        return 0;
}
int main()
{
    char arr[] = "bit";
    //int len = strlen(arr);
    //printf("%d\n", len);

    //模擬實現一個strlen函數
    int len = my_strlen(arr);
    printf("len = %d\n",len);
    return 0;
}

#include<stdio.h>
1 迭代方式
 int facl(int n)
{
    int i = 0;
    int ret = 1;
    for (i = 1; i <= n; i++)
    {
        ret = ret*i;
    }
    return ret;
}

遞歸方式
int facl(int n)
{
    if (n <= 1)
    {
        return 1;
    }
    else
        return n*facl(n - 1);
        這里說明一下思維
        假設 我們 要求 10 的階乘 1x1x2x3x4x5x6x7x8x9x10
        我們的 n 一開始是 10， 10*facl(n-1) ，其實 facl 函數 就是 把 10 減一，遞歸就好像是循環(huán)，循環(huán)的目的，就是 得到 10每次減一的結果，直到它等于1，再讓其鏈接起來，
        你可以這么看
        10 *(9 * (8 * (7 * ((6 * (5 * (4 *(3 * (2 * (1 * (1))))))))))
        等價于
        10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 * 1
}
int main()
{
    int n = 0;
    scanf("%d",&n);
    int ret = facl(n);//循環(huán)方式
    printf("%d\n",ret);
    return 0;
}

#include<stdio.h>
這題用遞歸效率很低，很多數會重復計算
int fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return fib(n - 1)+fib(n - 2);// 因為 函數 每得到一個數，就需要將得到的數進行分解成 2個 部分
}

2迭代（循環(huán)）方式（簡單加法）
效率更高
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\n",ret);
    return 0;
}