函数创建

#include<stdio.h>

void function_name(int, int);//在前面定义一个函数类型，可以不用传递实参

int main() {
    function_name(1, 1);//在这里进行赋值
}

void function_name(int a, int b) {//在这里对函数进行赋值，并创建俩个实参
    printf("hello");

}

让我们来注意一下区别：

void digui_function()中，这个函数不用返回任何值，也就是说，其不用return任何类型；
int digui_function()中，这个函数需要返回一个数据类型；

接下来是最重要的递归：

#include<stdio.h>
int digui_function(int n);
int main(){
  printf("%d",digui_function(5))}
int digui_function(int n){
  if(n==1)return 1;
  return digui_function(n-1)*n;
  

这个递归的本质就是将return语句中的digui_funtion(n-1)进行循环，直到return1截止，至此，digui_function(n-1),的目的就已经完成了，这时再次使用digui_function(n-1)*n进行数据返回，注意，在digui_function没有进行到return1时，*n这句代码，只起到过渡作用，在return语句中才再次时候用。

反思：

1. 首先，这仅仅是一个阶乘的算法我们甚至可以对最后一行代码这样理解：先进行return前面的递归，后再使用return进行回 值。
2. 那如果是累加呢，很明显，我们只要将*n变成+n就可以了。但请一定记住，如果
3. 一个小小的改变，如果我们写这样一个代码呢：

#include<stdio.h>
int Fabb_function(int n){


    if(n==1)return 1;


    return Fabb_function(n-1)+3;
}
int main(){
    printf("%d",Fabb_function(4));
}

此时，如果大家学过二叉树的话（或者有偷学过树的概念），就会很容易的发现，所谓的递归，在一定程度上就是特殊的树，树的分叉取决于我们想将函数分为几个递归"分叉"罢了。比如：（这里使用python进行展示）

class FatherTree:  
    def __init__(self, tree):  
        if tree > 0:  
            self.tree = tree - 1  
            self.father = FatherTree(self.tree)  
        else:  
            self.tree = tree  
            self.father = None

很明显，这种就属于“一根直肠通大脑”形，如果“父亲”值为1，那么就算递归一万次也是1，因为他没有什么数据的变化。

下面是单方面进行二叉树的：

class Node:  
    def __init__(self, value):  
        self.value = value  
        self.left = None  
        self.right = None  
  
def subtract_one(node):  
    if node is None:  
        return None  
    if node.right is None:  
        node.right = subtract_one(node.left)  
        return node  
    node.right = subtract_one(node.right)  
    return node  
  
root = Node(10)  
root.left = Node(5)  
root.right = Node(15)  
root.right.left = Node(13)  
root.right.right = Node(17)  
  
print("Original tree:")  
print_tree(root)  
  
root = subtract_one(root)  
  
print("\nAfter subtracting one:")  
print_tree(root)  
  
def print_tree(node):  
    if node is None:  
        return  
    print(node.value, end=" ")  
    print_tree(node.left)  
    print_tree(node.right)

下面是均进行递归操作的：

class Node:  
    def __init__(self, value):  
        self.value = value  
        self.left = None  
        self.right = None  
  
def subtract_one(node):  
    if node is None:  
        return None  
    node.value -= 1  
    if node.value < 0:  
        node.left = subtract_one(node.left)  
        node.right = subtract_one(node.right)  
    return node  
  
root = Node(10)  
root.left = Node(5)  
root.right = Node(15)  
root.right.left = Node(13)  
root.right.right = Node(17)  
  
print("Original tree:")  
print_tree(root)  
  
root = subtract_one(root)  
  
print("\nAfter subtracting one:")  
print_tree(root)  
  
def print_tree(node):  
    if node is None:  
        return  
    print(node.value, end=" ")  
    print_tree(node.left)  
    print_tree(node.right)

4.我们来进行一个提升：

#include<stdio.h>

int Fabb_function(int n) {
    int make_count;
    scanf_s("%d",&make_count); 
    if (n == 1)return 1;//count表示步幅，就是等差值；
    count++;
    return Fabb_function(n - 1) + count;
}

int main() {
    int number;
    scanf_s("%d",&number);
    printf("%d", Fabb_function(number));//表示可以得出的等差数量的和
}

这个程序问题很多，如果将来有机会的话会继续修改，大家可以对这个程序进行分析，就会发现很有意思，比如如果不初始化make_count会怎么样？（如果不是用scanf_s）,能不能作出他的函数呢？大家可以试一下，蛮有意思的。

（程序问题很多，这里仅仅只作为作者复习用，错误颇多请见谅）