判定条件： 对于整百的年份，闰年必定是400的倍数 ；对于不是整百的闰年，闰年是4的倍数

函数1：

int isleap(int year)
{
    if (year % 400 == 0)
    {
        return 1;
    }
    if (year%4==0)
    {
        if (year % 100 != 0)
	{
	    return 1;
	}
    }
    return 0;
}

我们把这两个条件集成一下，得到函数2

函数2：

#includeisleap(int year)
{
    if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
    //((year是4的倍数)并且(year不是100的倍数))或者(year是400的倍数)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int search(int arr[], int a, int sz)//形参为数组、需要查找的整数、数组的元素个数
{
    int left = 0;
    int right = sz - 1;
    int mid = 0;
    while (left<= right)
    {
        mid = left + (right - left) / 2;//找中间的元素
	if (arr[mid] >a)//中间元素大于查找值，就从右缩小一半的范围
	{
	    right = mid-1;//可以使用--mid，不推荐
	}
	else if (arr[mid]< a)//中间元素小于查找值，就从左缩小一半的范围
	{
	    left = mid+1;//可以使用++mid，不推荐
	}
	else
	{
	    return mid;//找到了，返回下标
	}
    }
    if (left>right) //正常情况下不会出现
    {
        return -1;//找不到，返回-1
    }
}

#includevoid test(int* p)//在主程序内定义一个变量储存调用的次数，因为需要改变变量的值，所以进行传址调用
{
    printf("hehe\n");
    (*p)++;//解引用找到变量再加1，注意这个括号不能忘
    //否则，*p++就表示每次这个指针先向后移动4个字节，然后解引用
}

函数可以根据需要进行相互调用。

#includeint main()
{
    printf("Hello world\n");
    return 0;
}

这是每一个初学者都会写的代码，我们先调用了main函数，然后在main函数的内部又调用了printf函数，这就是嵌套调用。

我们为了减少不必要变量的定义，可以直接把一个函数的返回值作为另一个函数的参数。

#include#includeint main()
{
    char arr[20] = "abcdef";
    printf("%d", strlen(arr));
    return 0;
}

strlen函数的返回值变成了printf函数的参数，这就把这两个函数像锁链一样串联起来，也就是链式访问。

这个程序的输出是什么？

#includeint main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
}

答案：4321

printf这个函数的返回值是它打印字符的个数，首先进入最外层的printf函数

这层函数需要第二层函数printf("%d", printf("%d", 43))的返回值

而第二层的printf函数又需要第三层函数printf("%d", 43)的返回值

在执行完第三层的printf("%d", 43)函数后，返回打印字符的个数2

printf("%d", printf("%d", 2))

第二层得到返回值2，打印2，而此时第二层函数也返回它打出的字符的个数1

printf("%d", 1)

最后打印1，也就形成了4321的输出结果

（1）函数的定义是指函数的具体实现，交待函数的功能实现。相当于我们平常创建自定义函数的步骤。

（2）函数不能嵌套定义

错误的定义方法：

int add(int x,int y)//加法函数
{
    return x + y;
    int sub(int x, int y)//这个减法函数被嵌套定义在了加法函数内部，这种写法是错的
    {
        return x - y;
    }
}

正确的定义方法：

int add(int x,int y)//加法函数
{
    return x + y;
}
int sub(int x, int y)//减法函数
{
    return x - y;
}

对于函数来讲，数数平等，不能搞特权。

函数的声明

• 函数的声明主要的目的在于告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。
• 但是这个函数具体存在不存在，函数声明决定不了。
• 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
• 函数的声明一般要放在头文件中的。

我们在写代码的时候可能会想：我把所有的代码写在一个源文件中，这样找起来不就方便了吗。

其实，这样的习惯对日后程序的开发是不利的。

我们的社会是有各自的分工的，当我们在开发一个程序的时候，我们往往只需要负责一个大的工程中的部分内容，比如一个人去写主程序，一个人写函数等等，而我们将工程的各个部分分开就可以更快地快找到bug并对应修复。

这样，当我们写一个函数时，就需要这样的文件分配：

• 函数声明——头文件.h
• 函数定义——函数实现的源文件.c

每一个函数都可以分成这两个文件编写，也可以几个函数写在两个文件中。

这里涉及到一个代码加密的问题，我会补充。

（1）递归的定义

程序调用自身的编程技巧称为递归（ recursion）。表示一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小

（2）递归的两个必要条件

• 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
• 每次递归调用之后越来越接近这个限制条件。

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

例如：输入：1234，输出 ：1 2 3 4

#includevoid print(int n) 
{
    if(n>9)
    {
        print(n/10);
    }
    printf("%d ", n%10);
}
int main()
{
    int num = 1234;
    print(num);
    return 0; 
}

（1）思想层面：大事化小

我们如果想要得到一个数字的每一位，就需要我们先%10得到最后一位，后/10除去最后一位，因为/10最后一位为余数,可以继续向前查找，直到这个数字成为一个一位数停止程序（因为如果这里是个一位数，a/10的值就是0，我们并不想打印0的每一位），所以在这里我们定义一个函数print()，它可以按顺序打印每一个值。

分步解决就是这样:

print(1234)

print(123) 4

print(12) 3 4

（2）实践讲解

print(1234);//这个函数从上到下，先递进后回归
//1234大于9，进入if语句,第一层
print(1234) 
{
    if(n>9)//n=1234,满足条件，进入if
    {
        print(123);
    }
    printf("%d ", n%10);//第一层，a%10=4
}
//print(123)展开，n=123满足条件，继续进入下一层
print(123) 
{
    if(n>9)//a/10=123,满足条件，进入if
    {
        print(12);
    }
    printf("%d ", n%10);//第二层，a%10=3
}
//print(12)展开，a/10=1此时不满足条件，不会继续进入下一层的if语句
print(12)
{
    if(n>9)//n=12,不满足条件，不进入if
    {
        print(1);
    }
    printf("%d ", n%10);//第三层，a%10=2
}
print(1)
{
    if(n>9)//n=1,不满足条件，不进入if
    {
        print(0);
    }
    printf("%d ", n%10);//第三层，a%10=1
}
递归的“递”此时已经完成，我们将这个代码整理一下，查看它时如何“归”的
print(1234) 
{
    {
        {
            {
                printf("%d ",n%10);//第四层，a%10=1
            }
            printf("%d ", n%10);//第三层，a%10=2
        }
        printf("%d ", n%10);//第二层，a%10=3
    }
    printf("%d ", n%10);//第一层，a%10=4
}
//代码从第四层开始向外执行，故可以实现数字的按位打印
//输出：1 2 3 4

（1）什么是迭代

迭代实际上就是重复，如果只讨论我们比较熟悉的程序设计操作，迭代在程序中就表示循环。

（2）函数递归和迭代的优缺点

函数递归中我们一层一层调用函数，它的优点是所需代码量少，简洁。但缺点主要有两个，一方面，大量重复的计算拖慢了程序的运行速度；另一方面，函数每一次被调用的时候都需要在栈区开辟相应的空间，当递归过深时可能会出现栈溢出。（栈区的空间已经被用完了，程序无法继续进行了）

当我们使用迭代时，循环不需要大量调用函数，重复的计算会少很多，这个程序的运行速度会加快不少，只是这个程序的代码量会大很多。（下面这个程序不是很明显，但也确实更短）

程序：应用递归求斐波那契数列的第n项

斐波那契数列：1 1 2 3 5 8 13 ...（规律：第一二项为1，后一项等于前两项的和）

递归程序：

#includeint fib(int m)
{
    int ret = 0;
    if (m<=2)
    {
        ret = 1;//第一二项为1
    }
    else 
    {
        ret = fib(m - 1) + fib(m - 2);//三项及三项以后，后一项等于前两项的和
    }
    return ret;
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    printf("%d",fib(n));
    return 0;
}

迭代程序：

#includeint fib(int m)
{	
    if (m< 2)//前两项为1
    {
        return 1;
    }
    else//后两项为前两项之和
    { 
        int i = 0;
	int a = 1;
	int b = 1;
	int c = 0;
	for (i=m; i>2; i--)
	{
	    c = a + b;
     	    a = b;//把原来的第二个数变成新计算中的第一个数
	    b = c;//把算出的结果变为新计算的第二个数
	}
	return c;
    }
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	printf("%d",fib(n));
	return 0;
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧