程序调用自身的编程技巧称为递归（ recursion），递归函数一定要有结束条件，否则会产生死递归，导致栈溢出（Stack overflow）。
#include <stdio.h>
int main()
{
printf("Hello\n");
main(); //main函数中用调用了main函数
return 0;
} //程序会一直打印 Hello递归作为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，使用递归可以在解决一些复杂问题时将问题简单化，降低编程难度。
递归的主要思考方式在于：把大事化小
递归就是递推回归的意思。
例如： 接收一个整型值（无符号），按照顺序打印它的每一位。
输入：1234，输出 1 2 3 4.
参考代码：
#include <stdio.h>
//接受一个整型值（无符号），按照顺序打印它的每一位。
//输入：1234，输出 1 2 3 4.
//使用函数递归
void print(int n)
{
if(n>9)//当n逐渐为1234 123 12 1时，无法进入if语句中，转向下一语句
{
print(n/10);//进入if语句后进行函数调用
}
printf("%d ", n%10);//打印出1%10 12%10 123%10 1234%10 的值
}
int main()
{
int num = 1234;
print(num);
return 0;
}
#include <stdio.h>
#include <math.h>
//将数字每一位打印出来
//无函数递归
int main()
{
int n = 1234;
int i = 0;
int ret = n;
for (i = 0; n != 0; i++)
{
n = n/10;//123 12 1 0
}
while (ret != 0)//123 12 1 0
{
int m = pow(10, i);// 3 2 1 0 1000 100 10 1
if(m<ret){
printf("%d ", ret / m);//1 2 3 4
}
ret = ret % m;//234 34 4
i--;
}
return 0;
}编写函数不允许创建临时变量，求字符串的长度。
参考代码：
#include <stdio.h>
//编写函数不允许创建临时变量，求字符串的长度。
int Strlen(const char*str)
{
if(*str == '\0')//字符串以\0为结尾
return 0;
else
return 1+Strlen(str+1);
}
int main()
{
char *p = "abcdef";
int len = Strlen(p);
printf("%d\n", len);
return 0;
}求n的阶乘。（不考虑溢出）
参考代码：
int factorial(int n)
{//求n的阶乘。（不考虑溢出）
if(n <= 1)
return 1;
else
return n * factorial(n-1); //1*2*3*4*……*n-1*n
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = factorial(n);
printf("%d\n", ret);
return 0;
}在测试中，使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
求第n个斐波那契数。（不考虑溢出）
参考代码：
int fib(int n)
{//求第n个斐波那契数。（不考虑溢出）
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}在测试中，如果使用 fib 这个函数的时候计算第50个斐波那契数字的时候特别耗费时间。
我们发现 fib 函数在调用的过程中很多计算其实在一直重复。
把代码修改一下：
int count = 0;//全局变量
int fib(int n)
{
if(n == 3)
count++;
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}最后我们输出看看count的值。
系统分配给程序的栈空间是有限的，如果调试 factorial 函数时参数较大，可能出现死递归情况，有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出（stack overflow）。
1. 将递归改写成非递归；
// //求n的阶乘
int factorial(int n)
{
int result = 1;
while (n > 1)
{
result *= n ;
n -= 1;
}
return result;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = factorial(n);
printf("%d\n", ret);
return 0;
}
//求第n个斐波那契数
int fib(int n)
{
int result;
int pre_result;
int next_older_result;
result = pre_result = 1;
while (n > 2)
{
n -= 1;
next_older_result = pre_result;
pre_result = result;
result = pre_result + next_older_result;
}
return result;
}2. 使用 static 对象替代 nonstatic 局部对象。在递归函数设计中可以使用 static 对象替代 nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放
nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。
比如接下来的题目:假如有n个台阶,一次只能上1个台阶或2个台阶，请问走到第n个台阶有几种走法?
#include <stdio.h>
//递归
int step(int n)
{
if(n <= 2)
return n;
return step(n-1)+step(n-2);
}
int main()
{
int n = 0;
scanf("%d",&n);
int ret = step(n);
printf("%d",ret);
return 0;
}实现：将参数字符串中的字符反向排列，不是逆序打印。
要求：不能使用C函数库中的字符串操作函数。
比如:
char arr[] = "abcdef";
逆序之后数组的内容变成：fedcba
#include <stdio.h>
void reverse_string(char * string)
{
if(*string != '\0')
reverse_string(string+1);//字符串逐渐后移一位，直到'\0'
if(*string != '\0')//为了不把'\0'打印出来
printf("%c",*string);
}
int main()
{
char arr[] = {"abcdefg"};
reverse_string(arr);
return 0;
}例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
输入：1729，输出：19
#include <stdio.h>
int DigitSum(int n)
{
static int sum = 0;
if(n>9)
DigitSum(n/10);//172 17 1
sum += n%10;//1+7+2+9
return sum;
}
int main()
{
int n = 0;
scanf("%d",&n);//输入一个非负整数
int ret = DigitSum(n);
printf("%d",ret);
return 0;
}#include <stdio.h>
int my_pow(int n,int k)
{
if(k == 0)
return 1;
else
return n*my_pow(n,k-1);
}
int main()
{
int n = 0;
int k = 0;
scanf("%d %d",&n,&k);
int ret = my_pow(n,k);
printf("%d",ret);
return 0;
}