递归、

1，递归过程的执行总是一个过程体未执行完，就带着本次执行的结果又进入到另一轮过程体的执行，........，如此反复，不断深入，直到某次过程的执行过程终止调用的条件成立，则不再继续深入，而执行本次的过程体余下的部分，然后又返回到上一次调用的过程体中，执行余下的部分，......，如此反复，直到回到起始位置上，才最终结束整个递归过程的执行，得到相应的执行结果。递归过程的核心就是参照这种执行流程，设计出一种适合“逐步深入，然后又逐步返回”的递归调用模型，以解决实际问题。

       递归算法应该包括递归情况和基底情况两种。递归情况演变到最后必须达到一个基底。递归函数有一个天生的问题，就是低效率问题，这是无法避免的。

       递归函数一般关注以下主要的几个因素：退出条件，参数有哪些，返回值是什么，局部变量有哪些，全局变量有哪些，何时输出，会不会导致堆栈溢出。

     举例：     

#include <iostream>
using namespace std;
int mystrlen(char *buf,int N)
{
    if (buf[0]==0||N==0)
        return 0;
    else if(N==1)
        return 1;
   int t = mystrlen(buf,N/2);
  if(t<N/2)
      return t;
  else
     return (t+mystrlen(buf+N/2,(N+1)/2));
}

int main()
{

   char buf0[]={'a','b','c','d','e','f','\0','x','y','z'};
   int k;
   k=mystrlen(buf,20);
   cout<<k<<endl;
   system("pause");
   return 0;
}

      求杨辉三角形，循环与递归对比，例子：

      

#include <iostream>

using namespace std;

#define RECURSION 0
#define NO_RECURSION 1

#if RECURSION
int f(int m, int n)
{
	if (1 == m)
	{
		return n;
	}
	if (1 == n)
	{
		return m;
	}
	return f(m - 1, n) + f(m, n - 1);
}
#endif

#if NO_RECURSION
int f(int m, int n)
{
	int a[100][100];
	for (int i = 0; i != m; ++i)
		a[i][0] = i + 1;
	for (int i = 0; i != n; ++i)
		a[0][i] = i + 1;
	for (int i = 1; i != m; ++i)
		for (int j = 1; j != n; ++j)
			a[i][j] = a[i - 1][j] + a[i][j - 1];
	return a[m - 1][n - 1];

  }

#endif

int main()
{
	cout << f(5, 5) << endl;
	system("pause");
	return 0;
}

       求zigzag数组，利用循环如下：

#include <stdio.h>
#include <iostream>

using namespace std;
int main()
{
	int N;
	int s, i, j;
	int squa;
	cin >> N;
	int **a = (int **)malloc(N * sizeof(int));
	if (a == NULL)
		return 0;
	for (i = 0; i < N; i++)
	{
		if ((a[i] = (int *)malloc(N * sizeof(int))) == NULL)
		{
			while (--i >= 0)
				free(a[i]);
			free(a);
			return 0;
		}
	}

	squa = N*N;
	for (i = 0; i < N; ++i)
	{
		for (j = 0; j < N; j++)
		{
			s = i + j;
			if (s < N)
				a[i][j] = s*(s + 1) / 2 + (((i + j) % 2 == 0) ? i : j);
			else
			{
				s = (N - 1 - i) + (N - 1 - j);
				a[i][j] = squa - s*(s + 1) / 2 - (N - (((i + j) % 2 == 0) ? i : j));
			}

			
		}
	}
	for (i = 0; i < N; i++)
	{
		for (j = 0; j < N; j++)
			printf("%6d", a[i][j]);
		    printf("\n");
	}
	system("pause");
	return 0;
}