递归示例(一)：遍历二叉树
最近做项目经常用到递归，刚开始很久没用，不太熟悉，现在研究了下，并写下了学习笔记及开发经验总结。
递归热身
一个算法调用自己来完成它的部分工作，在解决某些问题时，一个算法需要调用自身。如果一个算法直接调用自己或间接地调用自己，就称这个算法是递归的(Recursive)。根据调用方式的不同，它分为直接递归(Direct Recursion)和间接递归(Indirect Recursion)。 比如，在收看电视节目时，如果演播室中也有一台电视机播放的是与当前相同的节目，观众就会发现屏幕里的电视套有一层层的电视画面。这种现象类似于直接递归。
如果把两面镜子面对面摆放，便可从任意一面镜子里看到两面镜子无数个影像，这类似于间接递归。
一个递归算法必须有两个部分：初始部分(Base Case)和递归部分(Recursion Case)。初始部分只处理可以直接解决而不需要再次递归调用的简单输入。递归部分包含对算法的一次或多次递归调用，每一次的调用参数都在某种程度上比原始调用参数更接近初始情况。
函数的递归调用可以理解为：通过一系列的自身调用，达到某一终止条件后，再按照调用路线逐步返回。递归是程序设计中强有力的工具，有很多数学函数是以递归来定义的。
如大家熟悉的阶乘函数，我们可以对n!作如下定义：f(n)=
1 (n=1)
n*f(n-1) (n>=2)
一个算法具有的特性之一就是有穷性(Finity)：一个算法总是在执行有穷步之后结束，即算法的执行时间是有限的。递归算法当然也是算法，也满足算法的特性，因此递归不可能无限递归下去，总有一个终止条件。对该示例，递归的终止条件是n=1. 当n=1是，返回1，不在调用自己本身，递归结束。
class Program
{
static void Main(string[] args)
{
long result = function(20);
Console.WriteLine(result);
Console.ReadLine();
}
static long function(long n)
{
if (n == 1) //算法终止条件
{
return 1;
}
return n * function(n - 1);
}
}
递归算法通常不是解决问题最有效的计算机程序，因为递归包含函数调用，函数调用需要时空开销。所以，递归比其他替代选择诸如while循环等，所花费的代价更大。但是，递归通常提供了一种能合理有效地解决某些问题的算法。
递归示例(一)：遍历二叉树
二叉树是一种典型的树形结构，常用到递归算法来遍历。遍历按照根节点的相对顺序可分为前序遍历(DLR)、中序遍历(LDR)、后序遍历(RDL)。
对二叉树节点，有数据域存放数据，左孩子和右孩子为引用域存放孩子的引用：
|
左孩子 LChhild |
数据域 data |
右孩子 RChild |
/// <summary>
/// 二叉树节点
/// </summary>
/// <typeparam name="T"></typeparam>
public class Node<T>
{
private T data;//数据域
private Node<T> lChild;//左孩子
private Node<T> rChild;//右孩子
public Node()
{
data = default(T);
lChild = null;
rChild = null;
}
public Node(T data, Node<T> lChild, Node<T> rChild)
{
this.data = data;
this.lChild = lChild;
this.rChild = rChild;
}
public Node(Node<T> lChild, Node<T> rChild)
{
data = default(T);
this.lChild = lChild;
this.rChild = rChild;
}
public Node(T data)
: this(data, null, null)
{
this.data = data;
}
/// <summary>
/// 数据域
/// </summary>
public T Data
{
get { return data; }
set { this.data = value; }
}
/// <summary>
/// 左孩子
/// </summary>
public Node<T> LChild
{
get { return lChild; }
set { lChild = value; }
}
/// <summary>
/// 右孩子
/// </summary>
public Node<T> RChild
{
get { return rChild; }
set { rChild = value; }
}
}
先假设有以下结构的二叉树：
先在构造函数中简单构造下对应的数据：
public Node<string> A;
public 遍历二叉树()
{
A = new Node<string>("A");
Node<string> B = new Node<string>("B");
Node<string> C = new Node<string>("C");
Node<string> D = new Node<string>("D");
Node<string> E = new Node<string>("E");
Node<string> F = new Node<string>("F");
Node<string> G = new Node<string>("G");
Node<string> H = new Node<string>("H");
Node<string> I = new Node<string>("I");
Node<string> J = new Node<string>("J");
D.LChild = H;
D.RChild = I;
E.LChild = J;
B.LChild = D;
B.RChild = E;
C.LChild = F;
C.RChild = G;
A.LChild = B;
A.RChild = C;
}
前序遍历：先访问根结点A，然后分别访问左子树和右子树，把B及B的子孙看作一个结点处理，C及C的子孙看作一个结点处理，访问B时，把B当作根结点处理，B的左子树及左子树的子孙看作一个结点处理……可见，顺序依次是顶点-左孩子-右孩子（DLR），直到结点为叶子(即不包含子结点的结点)，即为递归的终止条件。对任意结点，只要结点确定，其左孩子和右孩子就确定，因此递归算法方法参数将结点传入即可。
/// <summary>
/// 前序遍历--DLR
/// </summary>
/// <param name="root"></param>
public void PreOrder(Node<T> root)
{
if (root == null)
{
return;
}
Console.Write("{0} ",root.Data);
//当节点无左孩子时，传入参数为null,下次调用即返回，终止
PreOrder(root.LChild);
//当节点无右孩子时，传入参数为null,下次调用即返回，终止
PreOrder(root.RChild);
}
同理，中序遍历和后序遍历如下：
/// <summary>
/// 中序遍历 LDR
/// </summary>
/// <param name="node"></param>
public void InOrder(Node<T> node)
{
//if (node == null)
//{
// return;
//}
//InOrder(node.LChild);
//Console.Write("{0} ",node.Data);
//InOrder(node.RChild);
//另外一种写法
if (node.LChild!=null)
{
InOrder(node.LChild);
}
Console.Write("{0} ", node.Data);
if (node.RChild != null)
{
InOrder(node.RChild);
}
}
/// <summary>
/// 后序遍历--LRD
/// </summary>
/// <param name="node"></param>
public void PostOrder(Node<T> node)
{
if (node == null)
{
return;
}
PostOrder(node.LChild);
PostOrder(node.RChild);
Console.Write("{0} ",node.Data);
}
/// <summary>
/// 层序遍历
/// </summary>
/// <param name="node"></param>
public void LevelOrder(Node<T> node)
{
if (node == null)
{
return;
}
Queue<Node<T>> sq = new Queue<Node<T>>();
//根结点入队
sq.Enqueue(node);
while (sq.Count != 0)
{
Node<T> tmp = sq.Dequeue(); //出队
Console.Write("{0} ",tmp.Data);
if (tmp.LChild != null)
{
sq.Enqueue(tmp.LChild);
}
if (tmp.RChild != null)
{
sq.Enqueue(tmp.RChild);
}
}
}
其中，另外一种写法就是在递归前判断下，满足递归条件才调用自己，这也是处理递归终止的一种方法。
static void Main(string[] args)
{
遍历二叉树<string> t = new 遍历二叉树<string>();
Console.Write("前序遍历：");
t.PreOrder(t.A);
Console.WriteLine();
Console.Write("中序遍历：");
t.InOrder(t.A);
Console.WriteLine();
Console.Write("后序遍历：");
t.PostOrder(t.A);
Console.WriteLine();
Console.Write("层序遍历：");
t.LevelOrder(t.A);
Console.ReadLine();
}
运行结果为：
递归示例(二)：WinForm之TreeView的应用—绑定区域树 http://www.cnblogs.com/sndnnlfhvk/archive/2011/03/31/2001064.html
递归示例(三)：WinForm之TreeView的应用—绑定磁盘目录(一) http://www.cnblogs.com/sndnnlfhvk/archive/2011/03/31/2001065.html
递归示例(四)：WinForm之TreeView的应用—绑定磁盘目录(二) http://www.cnblogs.com/sndnnlfhvk/archive/2011/03/31/2001072.html
