二叉树遍历函数的两种实现方法的比较

　　考虑下面一个二叉树的实现：

enum Operator {PLUS = 1, MINUS = 2, MULTIPLY = 3, DIVIDE = 4};

class BinTreeNode
{
public:
    virtual ~BinTreeNode() {};
    virtual bool IsLeaf() = 0;
};

class LeafNode : public BinTreeNode
{
private:
    double operand;
public:
    LeafNode(const double &op) : operand(op) {}
    bool IsLeaf() const { return true; }
    double GetOperand() const { return operand; }
};

class IntlNode : public BinTreeNode
{
public:
    IntlNode(BinTreeNode *l, BinTreeNode *r, Operator _op) : lc(l), rc(r), op(_op) {}
    bool IsLeaf() { return false; }
    BinTreeNode* GetLeftChild() const { return lc; }
    BinTreeNode* GetRightChild() const { return rc; }
    Operator GetOperator() const { return op; }
private:
    BinTreeNode *lc;
    BinTreeNode *rc;
    Operator op;
};

　　要对该二叉树实现前序遍历，有如下两种实现方法：

　　方法一：

void Traverse(BinTreeNode* root)
{
    if (root == nullptr)
    {
        return;
    }
    if (root->IsLeaf()) //结点为叶子结点
    {
        std::cout << "Leaf node: " << static_cast<LeafNode*>(root)->GetOperand() << std::endl;
    }
    else //内部结点
    {
        std::cout << "Internal node: " << static_cast<IntlNode*>(root)->GetOperator() << std::endl;
        Traverse(static_cast<IntlNode*>(root)->GetLeftChild());
        Traverse(static_cast<IntlNode*>(root)->GetRightChild());
    }
}

　　方法二：

　　首先在基类中将遍历函数声明为纯虚函数

class BinTreeNode
{
public:
    virtual ~BinTreeNode() {};
    virtual bool IsLeaf() = 0;
    virtual void Traverse() = 0;
};

　　随后定义如下函数：

void LeafNode::Traverse() const
{
    std::cout << "Leaf node: " << operand << std::endl;
}

void IntlNode::Traverse() const
{
    std::cout << "Internal node: " << op << std::endl;
    if (lc != nullptr)
    {
        GetLeftChild()->Traverse();
    }
    if (rc != nullptr)
    {
        GetRightChild()->Traverse();
    }
}

void Traverse(BinTreeNode *root)
{
    if (root != nullptr)
    {
        root->Traverse();
    }
}

　　对比：

　　从代码中可以看出，方法一不要求结点类支持Traverse()函数，但缺点在于定义在类外的Traverse()函数需要对结点类很熟悉，知道其实现细节，且添加新子类时需要修改Traverse()的代码；

　　而方法二要求对树实现遍历的操作要在结点类中实现，也因此，定义在类外的Traverse()函数不需要了解结点类的实现细节，遍历的处理工作由子类自行解决，且函数不需要枚举所有结点子类，直接就能进行合适的操作。

　　通常情况下，若有意把结点和树分开，需要隐藏结点类的内部细节，那应该选择使用方法二，反之则方法一更合适。