递归算法虽然简洁，但一般而言，其执行效率不高。因此，有时候要把递归算法转化为非递归算法。

先序遍历非递归算法

由先序遍历过程可知，先访问根节点，再访问左子树，最后访问右子树。因此，先将根节点进栈，在栈不空时循环如下：p出栈，访问*p结点，若右孩子不空将该右孩子结点进栈，若左孩子不空再将左孩子结点进栈。对应算法如下：

template <typename T>
void PreOrder(BTNode<T> * root) {
    BTNode<T> * St[MAX], *p;
    int top = -1;
    if (root != NULL) {
        top++;
        St[top] = root;
        while (top > -1) {
            p = St[top];
            top--;
            cout << p->data << " ";
            if (p->rchild != NULL) {
                top++;
                St[top] = p->rchild;
            }
            if (p->lchild != NULL) {
                top++;
                St[top] = p->lchild;
            }
        }
        cout << endl;
    }
}

中序遍历非递归算法

由中序遍历的过程可知，中序序列的开始结点是一棵二叉树的最左下结点，其基本思路是先找到二叉树的开始结点，访问它，在处理其右子树。由于二叉树链中指针的链接是单向的，因此采用一个栈保存需要返回的结点指针。其算法过程是：用指针指向当前要处理的结点。先扫描（并非访问）根结点的所有左结点并将他们一一进栈，当无左结点时表示栈顶结点无左子树，然后出栈这个结点，并访问它，将p指向刚出栈结点的右孩子，对右孩子进行同样的处理。需要注意的是，当结点*p的所有左下结点进栈后，这时的栈顶结点要么没有左子树要么其左子树已经访问过，就可以访问这个栈顶结点。如此这样，直到栈空为止。对应的算法如下：

template<typename T>
void InOrder(BTNode<T> * root) {
    BTNode<T> *St[MAX], *p;
    int top = -1;
    if (root != NULL) {
        p = root;
        while (top > -1 || p != NULL) {     //处理*root结点的左子树
            while (p != NULL) {             //扫描*p的所有左结点并进栈
                top++;
                St[top] = p;
                p = p->lchild;
            }
            //执行到此处，栈顶元素没有左孩子或左孩子树均已访问过
            if (top > -1) {
                p = St[top];                //出栈*p结点
                top--;
                cout << p->data << " ";     //访问数据
                p = p->rchild;              //转向处理*p的右孩子结点
            }
        }
        cout << endl;
    }
}

后序遍历非递归算法

在后序遍历中，对于每个结点，先访问其左子树，然后访问右子树，最后才是该结点本身。与中序遍历情况类似，后序遍历中第一个访问的结点是二叉树的最左下结点。由于首先访问结点的左右子树，而后才访问结点本身，所以必须告知地点，其左右子树是否访问过。

采用一个栈保存需要返回的结点指针，先扫描根结点的所有左结点并一一进栈，出栈一个结点*root作为当前结点，然后扫描该结点的右子树。当一个结点的左右孩子结点均访问后再访问该结点，如此循环直到栈空为止。

其中的难点是如何判断一个结点*root的右子树已访问过（实际上当root结点的右孩子结点已访问过的话，则其右子树就已访问过），为此用p保存刚刚访问过的结点（初值为NULL），若root->rchild == p成立（在后序遍历中，root的右孩子结点一定刚好在root之前访问过），说明*root的左右子树均已访问，现在应访问*root。

从上述过程可知，栈中保存的是当前结点*root的所有祖先结点（均未被访问过）。对应的算法如下：

template<typename T>
void PostOrder(BTNode<T> * root) {
    BTNode<T> *St[MAX], *p;
    int top = -1, flag;
    if (root != NULL) {
        do {
            while (root != NULL) {      //将*root所有左结点入栈
                top++;
                St[top] = root;
                root = root->lchild;
            }
            p = NULL;                   //p指向当前结点的前一个已访问的结点
            flag = 1;
            while (top != -1 && flag) {
                root = St[top];             //取出当前的栈顶元素
                if (root->rchild == p) {
                    cout << root->data << " ";
                    top--;
                    p = root;           //指向被访问的结点
                } else {
                    root = root->rchild;
                    flag = 0;
                }
            }
        } while (top != -1);
        cout << endl;
    }
}

层序遍历算法

在进行层序遍历时，对某一层的结点访问完后，再按照他们的访问次序对各个结点的左孩子和右孩子顺序访问，这样一层一层进行，先访问的结点其左右孩子也要先访问，这与队列的操作原则比较吻合。因此，在进行层序遍历时可设置一个队列存放已访问的结点。遍历从二叉树的根结点开始，首先将根指针入队，然后从队头取出一个元素，每取一个元素，执行下面的操作：
访问该结点；
若该结点的左右孩子非空，则将其左孩子和右孩子指针入队；
此过程不断进行，当队列为空时，二叉树的层次遍历结束。

template<typename T>
void LeverOrder(BTNode<T> * root) {
    int front;
    int rear = 0;
    BTNode<T> * Q[MAX];
    BTNode<T> * q;
    if (root == NULL) {
        return;
    } else {
        Q[rear++] = root;
        while (front != rear) {
            q = Q[front++];
            cout << q->data << " ";
            if (q->lchild != NULL) Q[rear++] = q->lchild;
            if (q->rchild != NULL) Q[rear++] = q->rchild;
        }
    }
}