关于二叉树的若干代码， 非递归遍历，打印..

#ifndef BINARY_TREE
#define BINARY_TREE

#include <iostream>
#include <stdio.h>
#include <stack>

using namespace std;

class binaryTree
{
private:
    struct btNode
    {
        char data;
        btNode *left, *right;
        btNode(char c):data(c){}
    };
    btNode *root;
    int size;

    //非递归后序遍历辅助数据的类型定义
    struct nodeTag
    {
        btNode *p;
        int tag;
        nodeTag(btNode *_p, int _tag):p(_p), tag(_tag){}
        nodeTag(){}
    };

    //线序遍历定义
    void preorderWalk(btNode *p)
    {
        if(p)
        {
            cout << p->data <<endl;
            preorderWalk(p->left);
            preorderWalk(p->right);
        }
    }

    //中序遍历定义
    void inorderWalk(btNode *p)
    {
        if(p)
        {
            inorderWalk(p->left);
            cout << p->data << endl;
            inorderWalk(p->right);
        }
    }

    //后序遍历定义
    void postorderWalk(btNode *p)
    {
        if(p)
        {
            postorderWalk(p->left);
            postorderWalk(p->right);
            cout << p->data << endl;
        }
    }

    //根据深度打印节点信息
    void printNode(char c, int h)
    {
        int i;
        for(i = 0; i < h; ++i)
        {
            cout << "  ";
        }
        cout << c << endl;
    }

    //打印树节点信息
    void printTree(btNode *t, int h)
    {
        if(!t)
        {
            printNode('*', h);
            return;
        }
        printTree(t->left, h + 1);
        printNode(t->data, h);
        printTree(t->right, h + 1);
    }

    //统计二叉树中节点个数
    int nodes(btNode *t)
    {
        if(!t)
        {
            return 0;
        }
        return nodes(t->left) + nodes(t->right);
    }

    //求二叉树的高度
    int height(btNode *t)
    {
        if(!t)
        {
            return 0;
        }
        int lh = height(t->left), rh = height(t->right);
        return 1 + (lh > rh ? lh : rh);
    }

    //求树中两节点的最长路径
    int heightForLR(btNode *t, int &lroad)
    {
        if(!t)
        {
            return 0;
        }
        int lh = height(t->left), rh = height(t->right);
        if(lh + rh > lroad)
        {
            lroad = lh + rh;
        }
        return 1 + (lh > rh ? lh : rh);
    }

    //建树函数
    btNode* buildBT()
    {
        char c;
        btNode *t = 0;
        c = getchar();
        if(c != ' ')
        {
            t = new btNode(c);
            ++size;
            t->left = buildBT();
            t->right = buildBT();
        }
        return t;
    }

    void drop(btNode* t)
    {
        if(t)
        {
            drop(t->left);
            drop(t->right);
            delete t;
        }
    }

public:
    binaryTree():root(0){}

    ~binaryTree()
    {
        drop(root);
    }

    //域外调用接口
    void walk()
    {
        preorderWalk(root);
    }

    void show()
    {
        printTree(root, 0);
    }

    int getSize()
    {
        return size;
    }

    int getHeight()
    {
        return height(root);
    }

    int longestRoad()
    {
        int x = 0;
        heightForLR(root, x);
        return x;
    }

    void build()
    {
        size = 0;
        root = buildBT();
    }

    //利用栈进行先序遍历
    void preWalkWithStack()
    {
        if(!root)
        {
            return;
        }
        stack<btNode*> aidS;
        aidS.push(root);
        btNode *p;
        while(!aidS.empty())
        {
            p = aidS.top();
            aidS.pop();
            cout << p->data <<endl;
            if(p->right)
            {
                aidS.push(p->right);
            }
            if(p->left)
            {
                aidS.push(p->left);
            }
        }
    }

    //利用栈实现中序遍历
    void inWalkWithStack()
    {
        stack<btNode*> aidS;
        btNode *p = root;
        while(p || !aidS.empty())
        {
            if(p)
            {
                aidS.push(p);
                p = p->left;
            }
            else
            {
                p = aidS.top();
                aidS.pop();
                cout << p->data <<endl;
                p = p->right;
            }
        }
    }

    //利用栈实现后序遍历
    void postWalkWithStack()
    {
        nodeTag nt;
        stack<nodeTag> aidS;
        aidS.push(nodeTag(root, 1));
        while(!aidS.empty())
        {
            nt = aidS.top();
            aidS.pop();
            if(nt.tag)
            {
                nt.tag = 0;
                aidS.push(nt);
                if(nt.p->right)
                {
                    aidS.push(nodeTag(nt.p->right, 1));
                }
                if(nt.p->left)
                {
                    aidS.push(nodeTag(nt.p->left, 1));
                }
            }
            else
            {
                cout << nt.p->data << endl;
            }
        }
    }
};

#endif