目录
本章主要讲解内容为：
- 树的非递归遍历算法，两种版本
- 树的扩展前缀以及前缀中缀构建方法
基础知识
一、定义
二叉树的递归定义：二叉树是每个结点最多含有两棵子树的树结构。
二、性质
二叉树的递归定义标识着它具有很多递归性质。
二叉树的遍历、查找、构建、删除、复制和计数等全部可以用递归来实现，详见代码。
三、构建
二叉树的构建方法有：硬编码生成、扩展前缀、前缀结合中缀等。我实现了后两种方法。
四、遍历
二叉树的递归遍历非常简单，参见代码。
主要分析二叉树的非递归遍历，除了书上的版本外，我自己另写了一个版本，称为通用方法，参照了指令及状态机所设计。不同之处：书上的代码仅用一个栈，而通用方法使用两个栈——指令栈和数据栈。
非递归遍历
一、普通方法
（I）前序遍历
递归遍历方法如下（伪代码）：
- pre_visit(node)
- {
- if(!node) return
- print node.data
- if(node.left) visit(node.left)
- if(node.right) visit(node.right)
- }
结合（根-左-右）遍历方式，思考递归方法下前序遍历的调用栈情况（步骤）：
- 从根结点root开始，访问根结点root并打印，接着访问左孩子lchild1，调用栈层数+1，父调用暂停在第5行
- 访问lchild1，接着访问lchild1的左孩子lchild2并打印，调用栈层数+1，父调用暂停在第5行
- …
- 访问到最左结点lchildn，调用栈层数=n，父调用暂停在第5行始，此时调用栈已经相对较深了
此时的调用栈：
n: visit(lchildn)，运行
n-1:visit(lchildn-1)，暂停在第5行
…
0: visit(root)，暂停在第5行 - 访问完lchildn，没有左孩子了，返回，调用栈出栈
此时的调用栈：
n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
…
0: visit(root)，暂停在第5行 - 继续（从lchildn到rchild1的访问变化是以lchildn-1为中间媒介的）
此时的调用栈：
n: visit(rchild1)，运行
n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
…
0: visit(root)，暂停在第5行 - 把rchild1看作root，类比步骤1~4
- 运行，直到访问完rchild1
- 继续，出栈
此时的调用栈：
n-2:visit(lchildn-2)，运行至第6行，访问右孩子rchild2
…
0: visit(root)，暂停在第5行 - 把rchild2看作root，类比步骤1~4
- 运行，直到访问完rchild2
- 继续，出栈
- …
- 直到调用栈为空
由此可以看出调用规律：
- 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0，并打印路径（因为路径上的结点依次已被访问过，故先打印根结点）
- 访问完最左结点left0，找到其父结点，即是栈顶left1，left1已访问过，故访问left1的右孩子right1
- 访问right1的方法参照调用规律1，是递归的
综上可以写出算法：
template <class T, class N>
void BiTree<T, N>::PreOrderNoRecursion2()
{
stack<N*> s;
N *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)//遍历到最左结点，同时记录路径，输出路径（根-左=(根->最左)路径）
{
cout << p->data;
s.push(p);
p = p->lchild;
}
if (!s.empty())
{
p = s.top();
s.pop();//访问后弹出最左结点，当前为最左父结点
p = p->rchild;//访问最左父结点的右孩子
}
}
}
（II）中序遍历
递归遍历方法如下（伪代码）：
- in_visit(node)
- {
- if(!node) return
- if(node.left) visit(node.left)
- print node.data
- if(node.right) visit(node.right)
- }
结合（左-根-右）遍历方式，思考递归方法下中序遍历的调用栈情况（步骤）：
- 从根结点root开始，访问左孩子lchild1（不打印），调用栈层数+1，父调用暂停在第4行
- 访问lchild1，接着访问lchild1的左孩子lchild2（不打印），调用栈层数+1，父调用暂停在第4行
- …
- 访问到最左结点lchildn并打印，调用栈层数=n，父调用暂停在第4行始，此时调用栈已经相对较深了
此时的调用栈：
n: visit(lchildn)，运行
n-1:visit(lchildn-1)，暂停在第4行
…
0: visit(root)，暂停在第4行 - 访问完lchildn，没有左孩子了，返回，调用栈出栈
此时的调用栈：
n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
…
0: visit(root)，暂停在第4行 - 访问lchildn-1（不打印），继续（从lchildn到rchild1的访问变化是以lchildn-1为中间媒介的，即访问lchildn-1的右子树）
此时的调用栈：
n: visit(rchild1)，运行
n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
…
0: visit(root)，暂停在第4行 - 把rchild1看作root，类比步骤1~4
- 运行，直到访问完rchild1
- 继续，出栈
此时的调用栈：
n-2:visit(lchildn-2)，运行至第6行，访问右孩子rchild2
…
0: visit(root)，暂停在第4行 - 把rchild2看作root，类比步骤1~4
- 运行，直到访问完rchild2
- 继续，出栈
- …
- 直到调用栈为空
由此可以看出调用规律：（其实与前序遍历有相似之处）
- 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0
- 访问完最左结点left0并打印，找到其父结点，即是栈顶left1，访问left1的右孩子right1（不打印）
- 访问right1的方法参照调用规律1，是递归的
- 结合规律2和3，可知：遍历完当前结点node后，应该遍历node的父结点（即栈顶）的右子树的最左结点，同样，这也是线索树的遍历顺序
综上可以写出算法：（就输出结果的那一行换了位置，总体逻辑是一样的，说明调用栈的变化规律也是一样的）
template <class T, class N>
void BiTree<T, N>::InOrderNoRecursion2()
{
stack<N*> s;
N *p = root;
while (p != NULL || !s.empty())
{
while (p != NULL)//定位到最左结点
{
s.push(p);
p = p->lchild;
}
if (!s.empty())
{
p = s.top();
cout << p->data;//从最左结点开始访问
s.pop();
p = p->rchild;//访问最左结点（依次）的父结点的右孩子
}
}
}
（III）后序遍历
后序遍历较前序、中序复杂，调用栈的变化规律不同于前序、中序。究其原因，是在输出之前有两次递归调用，因此，无法通过取栈顶知晓遍历的上一个结点（遍历的直接前驱），故必须以一变量来记录上一次访问的结点。
递归遍历方法如下（伪代码）：
- post_visit(node)
- {
- if(!node) return
- if(node.left) visit(node.left)
- if(node.right) visit(node.right)
- print node.data
- }
结合（左-根-右）遍历方式，思考递归方法下后序遍历的调用栈情况（步骤）：
- 从根结点root开始，访问左孩子lchild1（不打印），调用栈层数+1，父调用暂停在第4行
- 访问lchild1，接着访问lchild1的左孩子lchild2（不打印），调用栈层数+1，父调用暂停在第4行
- …
- 访问到最左结点lchildn并打印，调用栈层数=n，父调用暂停在第4行始，此时调用栈已经相对较深了
此时的调用栈：
n: visit(lchildn)，运行
n-1:visit(lchildn-1)，暂停在第4行
…
0: visit(root)，暂停在第4行 - 访问完lchildn，访问lchildn-1的右孩子lchildn-1_rchild（假设有右孩子），lchildn-1_rchild为root最左父结点的右孩子，假如lchildn-1没有右孩子（右子树），那么lchildn-1的子树已访问完，应该打印lchildn-1
此时的调用栈：
n: visit(lchildn-1_rchild)，运行
n-1:visit(lchildn-1)，暂停在第5行，访问右孩子
…
0: visit(root)，暂停在第4行 - 把lchildn-1_rchild看作root，类比步骤1~4
- 运行，直到访问完lchildn-1_rchild
- 打印lchildn-1_rchild（仅在lchildn-1有右孩子lchildn-1_rchild的情况下）此时的调用栈：
n: visit(lchildn-1_rchild)，运行至第6行，打印lchildn-1_rchild
n-1:visit(lchildn-1)，暂停在第5行，访问右孩子
…
0: visit(root)，暂停在第4行 - 继续，出栈
此时的调用栈：
n-1:visit(lchildn-1)，暂停在第6行，访问并打印最左父结点（在打印lchildn-1_rchild及其子结点之后才打印该结点lchildn-1）
…
0: visit(root)，暂停在第4行 - 继续，出栈，访问lchildn-2的右结点lchildn-2_rchild此时的调用栈：
n-1:visit(lchildn-2_rchild)，运行
n-2:visit(lchildn-2)，暂停在第5行
…
0: visit(root)，暂停在第4行 - 将lchildn-2_rchild看作root，运行步骤1~4（看步骤6，会发现很相似，都是遍历左结点的右子树）
- …
- 直到调用栈为空
设遍历过程中的前驱（上次遍历结点）为pre，由此可以看出调用规律：
- 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0
- 访问完最左结点left0并打印，找到其右兄弟，访问右兄弟right0，访问完right0就打印right0。
- 访问完right0后，找到并访问right0的父结点left1，访问完后，打印left1，left1访问完后，访问left2。
- 上述访问右兄弟right0的方法参照调用规律1，是递归的
算法的实现需要解决几个问题：
- 访问完当前结点后，如何找到其右兄弟
- 访问完子树后，如何找到父结点
以后序遍历为基础，结合pre这个前驱变量的特征，可以罗列出pre的指向：
- 有从子结点向父结点的过渡（父子过渡），此时pre=child，解决问题2
- 有从左结点向右结点的过渡（兄弟过渡），此时pre=left，无法解决问题1
要解决问题1，只能通过栈来解决。将要访问的孩子结点索性一次性保存到栈中，由于兄弟结点的遍历顺序是先左再右，故而进栈顺序为先右再左。
那么按照这个方法，处理当前结点时，将其孩子压栈，这是父结点向孩子结点的过渡，是通过栈的，没有借助pre。
因此可以写出基本步骤：
- 处理当前结点时，若孩子未访问过（pre<>孩子，兄弟过渡），就将孩子压栈（先右再左），自身不出栈（出栈后就没办法打印了），不使用pre
- 处理当前结点时，若孩子已访问过（pre=孩子），则打印自身，然后自身出栈，父子过渡，使用pre
现在，问题简化成：
- 什么情况下，将孩子压栈
- 什么情况下，访问本结点
以上两种情况之间互斥。
因而有：
- 压栈情况：孩子未访问过（pre<>lchild && pre<>rchild），且当前有孩子（lchild<>null || rchild<>null）
- 访问情况：除压栈情况以外的情况
综上可以写出算法：
template <class T, class N>
void BiTree<T, N>::PostOrderNoRecursion2()
{
stack<N*> s;
N *cur = root; //当前结点
N *pre = NULL; //前一次访问的结点
s.push(root);
while (!s.empty() && cur)
{
cur = s.top();
if ((cur->lchild == NULL&&cur->rchild == NULL) ||
((pre == cur->lchild || pre == cur->rchild)))
{
//当前为叶子结点或上一次访问为孩子结点，即按左-右-根（孩子-根）顺序，孩子全部访问过，接着访问父结点
cout << cur->data;
s.pop();
pre = cur;
}
else
{
//当前为从上到下访问，孩子没访问过，则孩子入栈
if (cur->rchild != NULL) s.push(cur->rchild);
if (cur->lchild != NULL) s.push(cur->lchild);//左-右-根，入栈顺序为(根)-右-左
}
}
}
二、通用方法
按指令拆解visit方法：
假设数据栈为s，指令栈为sip
- visit(bt)
- {
- //---- ins #0
- if(!bt)return //###return=>s.pop+sip.pop
- //---- ins #1 pre
- if(!bt.left)visit(bt.left) //###call visit(bt.left)=>s.push(bt.left)+sip.push(0)
- //---- ins #2 in
- if(!bt.right)visit(bt.right) //###call visit(bt.right)=>s.push(bt.right)+sip.push(0)
- //---- ins #3 post
- }
设一变量为ins，代表指令所在行，按正常的运行顺序，应是0->1->2->3->end。
如果在某处需要返回，则只需将指令出栈即可。
接下来，我们就可以在ins#0 #1 #2 #3这四处地方写上相应的处理程序。若无返回或者调用，则当前ins自增。
- ins#0，处理空值返回操作，判断数据栈顶是否为空，若为空则数据栈和指令栈都出栈一次。
- ins#1，处理前序遍历操作，打印结点数据，递归访问左结点。
- ins#2，处理中序遍历操作，打印结点数据，递归访问右结点。
- ins#3，处理后序遍历操作，打印结点数据，处理返回操作，数据栈和指令栈都出栈一次。
故算法如下：
template <class T, class N>
void BiTree<T, N>::MainOrderNoRecursion(typename BiTree<T, N>::NoRecursionType type)
{
if (root == NULL) return;
//非递归树遍历通用版本，结合状态机指令
stack<N*> s;//结点栈
stack<int> sip;//状态机
s.push(root);
sip.push(0);
while (!s.empty() || !sip.empty())
{
N* bt = s.top();//取结点栈顶
switch (sip.top())//取指令栈顶
{
case 0: sip.top()++;
if (bt == NULL)//遍历到NULL，出栈
{
s.pop();
sip.pop();
continue;
}
case 1: sip.top()++;
if (type == PREORDER) cout << bt->data;
if (bt->lchild != NULL)
{
s.push(bt->lchild);
sip.push(0);
continue;
}
case 2: sip.top()++;
if (type == INORDER) cout << bt->data;
if (bt->rchild != NULL)
{
s.push(bt->rchild);
sip.push(0);
continue;
}
case 3:
if (type == POSTORDER) cout << bt->data;
s.pop();
sip.pop();
continue;
}
throw "非法IP！";
}
}
树的构建
一、扩展前缀
所谓扩展前缀，顾名思义，必须是前缀编码，扩展就是以“#”代替空结点。
如常见的算术表达式：3+4*5，扩展前缀就是+3##*4##5##。其中？##代表叶子结点。
扩展前缀构建也采用递归调用方式。
将前缀看作[Head] [Left] [Right]三个部分，返回一棵树。[Head]只有一个元素，直接取出来，作为父结点。那两个子结点就从[Left] [Right]这两个前缀中生成，这即是递归调用。
template <class T, class N>
N *BiTree<T, N>::CreateByPre(int& ipre)
{
if (ipre >= (int)pre.size())
throw "输入串错误";
T e = pre[ipre++];
if (e == ‘\0‘) return NULL;
if (e == ‘#‘) return NULL;
N *bt = New();
bt->data = e;
bt->lchild = CreateByPre(ipre); // 建左子树
bt->rchild = CreateByPre(ipre); // 建右子树
return bt;
}
二、前缀与中缀
把扩展前缀的“#”规则拿掉，那普通的前缀字串就无法生成一棵唯一的树了，究其原因，是无法知晓递归调用的出口，而“#”恰恰是递归的出口。
知道一棵树的前缀和中缀，就能够还原这棵树，条件是树的结点值不能有重复，也就是说，前缀和中缀能够完全确定一棵树，如何证明？
假设前缀为pre，中缀为in，pre和in的长度是n。将其作划分：
- pre=[Head] [Head-Left] [Head-Right]
- in=[Head-Left] [Head] [Head-Right]
现在，假设in中Head的下标为k，则Head-Left中缀的范围就是[0,k-1]，Head-Right中缀的范围就是[k+1,n-1]。
这样，经过一轮划分，生成一棵不完全中缀树——父结点为Head，孩子为Head-Left和Head-Right，且此树是唯一的。
接下来，按照同样方法，只不过这次划分的对象是Head-Left和Head-Right，重复直到Head-Left或Head-Right长度为1（即叶子结点）。
现在思想为什么树的结点值不能重复，关键在于在in中寻找Head——如果Head有多个，就不能保证找到了正确的Head。
举例：
- pre = *+xyz
- in = x+y*z
第一次划分后：
- pre = * [+xy] [z]
- in = [x+y] * [z]
第二次划分后：
- pre = * [+ [x] [y]] [z]
- in = [[x] + [y]] * [z]
有优先级（括号）的中缀可以确定一棵二叉树，因此，该方法有效，一般的前缀和中缀可以还原二叉树。
template <class T, class N>
N* BiTree<T, N>::CreateByPreMid(int ipre, int imid, int n)
{
if (n == 0) return NULL;
N *p = New();
p->data = pre[ipre];// 前缀为根-左-右
int i;
for (i = 0; i < n; i++) // 在中序序列中定位根结点
{
if (pre[ipre] == mid[imid + i]) break;
}
if (i == n) throw "前缀和中缀字符不匹配！";
p->lchild = CreateByPreMid(ipre + 1, imid, i);// 建左子树
p->rchild = CreateByPreMid(ipre + i + 1, imid + i + 1, n - i - 1);// 建右子树
return p;
}
总结
二叉树是计算机数据结构当中的核心内容，它本身有着优美的递归性质。
树结构在查找方面有平衡二叉树AVL、红黑树RBT等，在数据压缩方面有哈夫曼树等，在图形学领域有四叉树、八叉树等等，因而，掌握好树结构对于学习计算机算法而言是不可或缺的。