递归在WinForm中的应用
最近做项目经常用到递归，刚开始很久没用，不太熟悉，现在研究了下，并写下了学习笔记及开发经验总结。
递归热身
一个算法调用自己来完成它的部分工作，在解决某些问题时，一个算法需要调用自身。如果一个算法直接调用自己或间接地调用自己，就称这个算法是递归的(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的应用—绑定区域树
C#中的树很多。比如，Windows Form程序设计和Web程序设计中都有一种被称为TreeView的控件。TreeView控件是一个显示树形结构的控件，此树形结构与Windows资源管理器中的树形结构非常类似。不同的是，TreeView可以由任意多个节点对象组成。每个节点对象都可以关联文本和图像。另外，Web程序设计中的TreeView的节点还可以显示为超链接并与某个URL相关联。每个节点还可以包括任意多个子节点对象。包含节点及其子节点的层次结构构成了TreeView控件所呈现的树形结构。
下面是很典型的一个例子，就是用TreeView绑定数据。数据一般符合树形结构，如行政区域之间的关系、公司部门与部门员工之间关系、磁盘目录文件之间的关系等。
父级与子级之间满足一对多的关系，因此在数据库设计中常用一字段来做本表主键的外键，代表父级区域ID。当然，如果要方便求子孙的算法（例如列举武汉所有子区域）可以另加一字段，记录从根结点到当前结点所经历的结点ID。
思路分析：
1. 获取表Area中的所有数据，存放到DataTable中。
2. 获取根结点的数据并添加到根节点。根结点的处理常与子结点的递归处理不一样，例如根结点的添加是在treeView1.Nodes.Add里面，而子结点递归是在父结点上添加，因此经常要分开处理。获取根结点数据可用DataTable.Select(“fAreaId=-1”)来获取。绑定结点时，将Node.Text设为区域的名字，Node.Tag设为区域对应的数据行DataRow或者区域的ID，这样遍历子区域就知道父结点区域信息，也方便应用程序获取选中的结点对应的数据。
3. 递归遍历子区域并添加到TreeView控件中。递归方法参数为Node,由父级Node.Tag就能获取父级区域数据信息，进而获取其子区域，获取子区域可用
DataRow[] rows=DataTable.Select(“fAreaId=”+父级区域ID)。获取子区域后将其获取的信息绑定到新建的Node对象，方法同第二步，然后递归调用自己。当区域不包含任何子区域时，递归终止,即rows.Length==0.
代码如下：
public partial class BindAreaForm : Form
{
private DataTable dt = null;
public BindAreaForm()
{
InitializeComponent();
InitDataTable();
}
//获取Area所用数据
private void InitDataTable()
{
SqlConnection conn = new SqlConnection(“Data Source=.;Initial Catalog=Test;Integrated Security=True”);
SqlCommand cmd = new SqlCommand(“SELECT * FROM Area”, conn);
SqlDataAdapter ada = new SqlDataAdapter(cmd);
dt = new DataTable();
ada.Fill(dt);
}
private void BindAreaForm_Load(object sender, EventArgs e)
{
BindRoot();
}
//绑定根节点
private void BindRoot()
{
DataRow[] rows = dt.Select(“fAreaId=-1”);//取根
foreach (DataRow dRow in rows)
{
TreeNode rootNode = new TreeNode();
rootNode.Tag = dRow;
rootNode.Text = dRow[“AreaName”].ToString();
treeView1.Nodes.Add(rootNode);
BindChildAreas(rootNode);
}
}
//递归绑定子区域
private void BindChildAreas(TreeNode fNode)
{
DataRow dr = (DataRow)fNode.Tag;//父节点数据关联的数据行
int fAreaId = (int)dr[“id”]; //父节点ID
DataRow[] rows = dt.Select(“fAreaId=”+fAreaId);//子区域
if (rows.Length == 0) //递归终止，区域不包含子区域时
{
return;
}
foreach (DataRow dRow in rows)
{
TreeNode node = new TreeNode();
node.Tag = dRow;
node.Text = dRow[“AreaName”].ToString();
//添加子节点
fNode.Nodes.Add(node);
//递归
BindChildAreas(node);
}
}
}
运行截图：
递归示例(三)：WinForm之TreeView的应用—绑定磁盘目录(一)
磁盘文件系统结构符合树形结构，可以把“我的电脑”或者驱动器看做是树的根(多个驱动器看做多个根吧，做多课树处理)，文件夹下面可以包含文件夹或文件，文件则是树的叶子，不能再分，显然，这也是递归的终止条件。
思路分析：
1. 获取要绑定的目录，此目录为treeView控件的根。将结点的Tag设置成觉对路径，以便子节点获取父结点信息。
2.递归遍历子目录和文件，当绝对路径对应的DirectoryInfo为文件时，递归终止。这里要提一下，网上很多判断文件时文件夹还是文件都用后缀来判断，无后缀则为文件夹，这样是不正确的，例如host文件就没后缀，但它是文件而不是文件夹，还有很多软件的缓存文件也没后缀的，把它们当文件夹来处理遍历访问子目录显然有异常。正确的方法是用FileSystemInfo类的GetType()方法。
public partial class MainForm : Form
{
public MainForm()
{
InitializeComponent();
}
private void MainForm_Load(object sender, EventArgs e)
{
TreeNode root = new TreeNode();
root.Text = @”战国无双2″;
root.Tag = @”E:/战国无双2″;
treeView1.Nodes.Add(root);
BindChild(root);
}
private void BindChild(TreeNode fNode)
{
string path = fNode.Tag.ToString();
//父目录
DirectoryInfo fDir = new DirectoryInfo(path);
FileSystemInfo[] finfos = fDir.GetFileSystemInfos();
foreach (FileSystemInfo f in finfos)
{
string type = f.GetType().ToString();
TreeNode node = new TreeNode();
node.Text = f.Name;
node.Tag = f.FullName;
fNode.Nodes.Add(node);
if (“System.IO.DirectoryInfo” == type) //是文件夹时才递归调用自己
{
BindChild(node);
}
}
}
运行截图如下：
总结：
TreeView递归绑定一般分两大步，第一步对根结点操作及输入绑定，并将结点关联数据传入递归；第二步主要是递归终止的控制，控制终止一般有两种方法：一是在递归方法开始判断是否满足递归终止条件，是则显式return返回，否则继续调用自己；另外一种方法是在调用自己前判断是否满足递归的条件，满足条件才调用自己。两种方法具体看程序。
当把上面的目录改为比较大的目录例如C:/Windows时，发现加载要很多时间。针对这个问题，请看下一篇：动态加载结点。
递归示例(四)：WinForm之TreeView的应用—绑定磁盘目录(二)
当具有树形结构的数据的结点很多而且树的深度比较大时，直接用递归遍历明显能发现性能很低。因此，不要一次全部加载，而是当用户点击展开时才加载此结点下的子结点。
实现要点：
每加载添加一个结点时，判断该结点是否为叶子(即不含子结点)，若包含子结点，先添加一个空的子节点，这样做主要是让用户在界面能看到“+”表示结点能展开。当用户点击“+”时触发treeView_AfterExpand事件，在该事件中处理添加子结点数据，添加之前，清理删除掉以前的结点。
public partial class MainForm2 : Form
{
public MainForm2()
{
InitializeComponent();
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
}
private void MainForm2_Load(object sender, EventArgs e)
{
BindDrives();
}
private void BindDrives()
{
DriveInfo[] drvs = DriveInfo.GetDrives();
foreach (DriveInfo drv in drvs)
{
TreeNode root = new TreeNode();
root.Text = drv.Name;
root.Tag = drv.RootDirectory.ToString();
// root.Nodes.Add(“”);
treeView1.Nodes.Add(root);
if (Directory.Exists(drv.RootDirectory.ToString()))
{
DirectoryInfo dInfo = new DirectoryInfo(drv.RootDirectory.ToString());
FileSystemInfo[] files = dInfo.GetFileSystemInfos();
if (files.Length > 0) //有子节点，先添加一个空节点
{
root.Nodes.Add(“emptyNode”, string.Empty);
}
}
}
}
//展开节点，移除以前的空节点，加载子节点
private void treeView1_AfterExpand(object sender, TreeViewEventArgs e)
{
TreeNode parentNode = e.Node;
// parentNode.Nodes.RemoveByKey(“emptyNode”);//移除空节点
parentNode.Nodes.Clear();
string path = parentNode.Tag.ToString();
if (Directory.Exists(path))
{
DirectoryInfo dir = new DirectoryInfo(path);
FileSystemInfo[] files = dir.GetFileSystemInfos();
foreach (FileSystemInfo f in files)
{
TreeNode node = new TreeNode();
node.Text = f.Name;
node.Tag = f.FullName;
parentNode.Nodes.Add(node); //加载子节点
if (Directory.Exists(node.Tag.ToString()))
{
DirectoryInfo subDir = new DirectoryInfo(node.Tag.ToString());
if (subDir.Attributes != (FileAttributes.System | FileAttributes.Hidden | FileAttributes.Directory))
{
FileSystemInfo[] subFiles = subDir.GetFileSystemInfos();
if (subFiles.Length > 0) //有子节点，先添加一个空节点
{
node.Nodes.Add(“emptyNode”, string.Empty);
}
}
}
}
}
运行结果如图：
这样，只加载用户要展开的结点，而且每次只加载当前结点的下一代，性能明显能提升，当然还能用多线程技术改善性能、用WindowsAPI获取文件图标并关联TreeView结点，这里就不介绍了。
杨盛超
2011年3月31日
