BinTree：：遍历

template <typename VST> //操作器
void travLevel(VST& visit) { if (_root) _root->travLevel(visit); } //层次遍历
template <typename VST> //操作器
void travPre(VST& visit) { if (_root) _root->travPre(visit); } //先序遍历
template <typename VST> //操作器
void travIn(VST& visit) { if (_root) _root->travIn(visit); } //中序遍历
template <typename VST> //操作器
void travPost(VST& visit) { if (_root) _root->travPost(visit); } //后序遍历

/*DSA*/#include "../stack/Stack.h" //引入栈模板类
/*DSA*/#include "BinNode_TravPreorder_R.h"
/*DSA*/#include "BinNode_TravPreorder_I1.h"
/*DSA*/#include "BinNode_TravPreorder_I2.h"
template <typename T> template <typename VST> //元素类型、操作器
void BinNode<T>::travPre(VST& visit) { //二叉树先序遍历算法统一入口
switch (rand() % 3) { //此处暂随机选择以做测试，共三种选择
case 1: travPre_I1(this, visit); break; //迭代版#1
case 2: travPre_I2(this, visit); break; //迭代版#2
default: travPre_R(this, visit); break; //递归版
}
}

template <typename T, typename VST> //元素类型、操作器
void travPre_R(BinNodePosi(T) x, VST& visit) { //二叉树先序遍历算法（递归版）
if (!x) return;
visit(x->data);
travPre_R(x->lChild, visit);
travPre_R(x->rChild, visit);
}

template <typename T, typename VST> //元素类型、操作器
void travPre_I1(BinNodePosi(T) x, VST& visit) { //二叉树先序遍历算法（迭代版#1）
Stack<BinNodePosi(T)> S; //辅助栈
if (x) S.push(x); //根节点入栈
while (!S.empty()) { //在栈变空之前反复循环
x = S.pop(); visit(x->data); //弹出并访问当前节点，其非空孩子的入栈次序为
if (HasRChild(*x)) S.push(x->rChild); if (HasLChild(*x)) S.push(x->lChild); //先右后左
}
}

//从当前节点出发，沿左分支不断深入，直至没有左分支的节点；沿途节点遇到后立即访问
template <typename T, typename VST> //元素类型、操作器
static void visitAlongLeftBranch(BinNodePosi(T) x, VST& visit, Stack<BinNodePosi(T)>& S) {
while (x) {
visit(x->data); //访问当前节点
S.push(x->rChild); //右孩子入栈暂存（可优化：通过判断，避免空的右孩子入栈）
x = x->lChild;  //沿左分支深入一层
}
}

template <typename T, typename VST> //元素类型、操作器
void travPre_I2(BinNodePosi(T) x, VST& visit) { //二叉树先序遍历算法（迭代版#2）
Stack<BinNodePosi(T)> S; //辅助栈
while (true) {
visitAlongLeftBranch(x, visit, S); //从当前节点出发，逐批访问
if (S.empty()) break; //直到栈空
x = S.pop(); //弹出下一批的起点
}
}

/*DSA*/#include "../stack/Stack.h" //引入栈模板类
/*DSA*/#include "BinNode_TravInorder_R.h"
/*DSA*/#include "BinNode_TravInorder_I1.h"
/*DSA*/#include "BinNode_TravInorder_I2.h"
/*DSA*/#include "BinNode_TravInorder_I3.h"
/*DSA*/#include "BinNode_TravInorder_I4.h"
template <typename T> template <typename VST> //元素类型、操作器
void BinNode<T>::travIn(VST& visit) { //二叉树中序遍历算法统一入口
switch (rand() % 5) { //此处暂随机选择以做测试，共五种选择
case 1: travIn_I1(this, visit); break; //迭代版#1
case 2: travIn_I2(this, visit); break; //迭代版#2
case 3: travIn_I3(this, visit); break; //迭代版#3
case 4: travIn_I4(this, visit); break; //迭代版#4
default: travIn_R(this, visit); break; //递归版
}
}

template <typename T, typename VST> //元素类型、操作器
void travIn_R(BinNodePosi(T) x, VST& visit) { //二叉树中序遍历算法（递归版）
if (!x) return;
travIn_R(x->lChild, visit);
visit(x->data);
travIn_R(x->rChild, visit);
}

template <typename T> //从当前节点出发，沿左分支不断深入，直至没有左分支的节点
static void goAlongLeftBranch(BinNodePosi(T) x, Stack<BinNodePosi(T)>& S) {
while (x) { S.push(x); x = x->lChild; } //当前节点入栈后随即向左侧分支深入，迭代直到无左孩子
}

template <typename T, typename VST> //元素类型、操作器
void travIn_I1(BinNodePosi(T) x, VST& visit) { //二叉树中序遍历算法（迭代版#1）
Stack<BinNodePosi(T)> S; //辅助栈
while (true) {
goAlongLeftBranch(x, S); //从当前节点出发，逐批入栈
if (S.empty()) break; //直至所有节点处理完毕
x = S.pop(); visit(x->data); //弹出栈顶节点并访问之
x = x->rChild; //转向右子树
}
}

template <typename T, typename VST> //元素类型、操作器
void travIn_I2(BinNodePosi(T) x, VST& visit) { //二叉树中序遍历算法（迭代版#2）
Stack<BinNodePosi(T)> S; //辅助栈
while (true)
if (x) {
S.push(x); //根节点进栈
x = x->lChild; //深入遍历左子树
} else if (!S.empty()) {
x = S.pop(); //尚未访问的最低祖先节点退栈
visit(x->data); //访问该祖先节点
x = x->rChild; //遍历祖先的右子树
} else
break; //遍历完成
}

template <typename T> BinNodePosi(T) BinNode<T>::succ() { //定位节点v的直接后继
BinNodePosi(T) s = this; //记录后继的临时变量
if (rChild) { //若有右孩子，则直接后继必在右子树中，具体地就是
s = rChild; //右子树中
while (HasLChild(*s)) s = s->lChild; //最靠左（最小）的节点
} else { //否则，直接后继应是“将当前节点包含于其左子树中的最低祖先”，具体地就是
while (IsRChild(*s)) s = s->parent; //逆向地沿右向分支，不断朝左上方移动
s = s->parent; //最后再朝右上方移动一步，即抵达直接后继（如果存在）
}
return s;
}

template <typename T, typename VST> //元素类型、操作器
void travIn_I3(BinNodePosi(T) x, VST& visit) { //二叉树中序遍历算法（迭代版#3，无需辅助栈）
bool backtrack = false; //前一步是否刚从右子树回溯——省去栈，仅O(1)辅助空间
while (true)
if (!backtrack && HasLChild(*x)) //若有左子树且不是刚刚回溯，则
x = x->lChild; //深入遍历左子树
else { //否则——无左子树或刚刚回溯（相当于无左子树）
visit(x->data); //访问该节点
if (HasRChild(*x)) { //若其右子树非空，则
x = x->rChild; //深入右子树继续遍历
backtrack = false; //并关闭回溯标志
} else { //若右子树空，则
if (!(x = x->succ())) break; //回溯（含抵达末节点时的退出返回）
backtrack = true; //并设置回溯标志
}
}
}

template <typename T, typename VST> //元素类型、操作器
void travIn_I4(BinNodePosi(T) x, VST& visit) { //二叉树中序遍历算法（迭代版#4，无需栈或标志位）
while (true)
if (HasLChild(*x)) //若有左子树，则
x = x->lChild; //深入遍历左子树
else { //否则
visit(x->data); //访问当前节点，并
while (!HasRChild(*x)) //不断地在无右分支处
if (!(x = x->succ())) return; //回溯至直接后继节点（在没有后继的末节点处，直接退出）
else visit(x->data); //访问新的当前节点
x = x->rChild; //（直至有右分支处）转向非空的右子树
}
}

/*DSA*/#include "../stack/Stack.h" //引入栈模板类
/*DSA*/#include "BinNode_TravPostorder_R.h"
/*DSA*/#include "BinNode_TravPostorder_I.h"
template <typename T> template <typename VST> //元素类型、操作器
void BinNode<T>::travPost(VST& visit) { //二叉树后序遍历算法统一入口
switch (rand() % 2) { //此处暂随机选择以做测试，共两种选择
case 1: travPost_I(this, visit); break; //迭代版
default: travPost_R(this, visit); break; //递归版
}
}

template <typename T, typename VST> //元素类型、操作器
void travPost_R(BinNodePosi(T) x, VST& visit) { //二叉树后序遍历算法（递归版）
if (!x) return;
travPost_R(x->lChild, visit);
travPost_R(x->rChild, visit);
visit(x->data);
}

template <typename T> //在以S栈顶节点为根的子树中，找到最高左侧可见叶节点
static void gotoHLVFL(Stack<BinNodePosi(T)>& S) { //沿途所遇节点依次入栈
while (BinNodePosi(T) x = S.top()) //自顶而下，反复检查当前节点（即栈顶）
if (HasLChild(*x)) { //尽可能向左
if (HasRChild(*x)) S.push(x->rChild); //若有右孩子，优先入栈
S.push(x->lChild); //然后才转至左孩子
} else //实不得已
S.push(x->rChild); //才向右
S.pop(); //返回之前，弹出栈顶的空节点
}

template <typename T, typename VST>
void travPost_I(BinNodePosi(T) x, VST& visit) { //二叉树的后序遍历（迭代版）
Stack<BinNodePosi(T)> S; //辅助栈
if (x) S.push(x); //根节点入栈
while (!S.empty()) {
if (S.top() != x->parent) //若栈顶非当前节点之父（则必为其右兄），此时需
gotoHLVFL(S); //在以其右兄为根之子树中，找到HLVFL（相当于递归深入其中）
x = S.pop(); visit(x->data); //弹出栈顶（即前一节点之后继），并访问之
}
}

/*DSA*/#include "../queue/queue.h" //引入队列
template <typename T> template <typename VST> //元素类型、操作器
void BinNode<T>::travLevel(VST& visit) { //二叉树层次遍历算法
Queue<BinNodePosi(T)> Q; //辅助队列
Q.enqueue(this); //根节点入队
while (!Q.empty()) { //在队列再次变空之前，反复迭代
BinNodePosi(T) x = Q.dequeue(); visit(x->data); //取出队首节点并访问之
if (HasLChild(*x)) Q.enqueue(x->lChild); //左孩子入队
if (HasRChild(*x)) Q.enqueue(x->rChild); //右孩子入队
}
}