再谈二叉树：三种遍历六种实现

二叉树的遍历：前序、中序’后序，其实，是以根节点的访问顺序来确定的，具体看下面：

//记法：根节点的遍历顺序就是树的遍历顺序
    /************************************************************************/
    // V --访问根节点
    // L --遍历左子树
    // R -- 遍历右子树
    // VLR--前序遍历   //注意V的位置
    // LVR --中序遍历
    // LRV --后序遍历
    /************************************************************************/

，下面是代码：

//二叉搜索树
template<typename T> class BSTNode {
public:
    BSTNode():left(0),right(0) {}
    BSTNode(const T & el, BSTNode* l = 0, BSTNode* right = 0) :key(el), left(l), right(r) {}
    T key;
    BSTNode<T>  *left, *right;
public:
    //查找函数
    T* search(BSTNode<T>* p, const T& el)const {
        while (p != NULL)
        {
            if (el == p->key) {
                return &p->key;
            }
            else if (el < p->key) {
                p = p->left;
            }
            else {
                p = p->right;
            }
        }
        return 0;
    }

    //广度优先遍历
    void breadthFirst(BSTNode<T>* root) {
        queue<BSTNode<T>*> nodes;
        BSTNode<T>* p = root;
        if (p != NULL) {
            nodes.push(p);
            while (!nodes.empty())
            {
                p = nodes.front();
                nodes.pop();
                cout << p->key << endl;
                if (p->left != 0) {
                    nodes.push(p->left);
                }
                if (p->right != 0) {
                    nodes.push(p->right);
                }
            }
        }
    }

    void visit(BSTNode<T>* node)const {
        cout << node->key << endl;
    }
    //记法：根节点的遍历顺序就是树的遍历顺序
    /************************************************************************/
    // V --访问根节点
    // L --遍历左子树
    // R -- 遍历右子树
    // VLR--前序遍历   //注意V的位置
    // LVR --中序遍历
    // LRV --后序遍历
    /************************************************************************/

    //中序遍历
    void inorder(BSTNode<T>* p) {
        if (p != NULL) {
            inorder(p->left);
            visit(p);
            inorder(p->right);
        }
    }
    /************************************************************************/
    /* 中序遍历 非递归实现                                                                     */
    /************************************************************************/
    void iterativeInorder(BSTNode<T>* root) {
        stack<BSTNode<T>*> travStack;
        BSTNode<T> *p = root;
        while (p != 0) {
            if (p->right) {
                travStack.push(p->right);
            }
            travStack.push(p);
            p = p->left;
        }

        p = travStack.pop();
        while (!travStack.empty()) {
            visit(p);
            p = travStack.pop();
        }

        visit(p);
        if (!travStack.empty()) {
            p = travStack.pop();
        }
        else {
            p = 0;
        }
    }


    //前序遍历
    void preorder(BSTNode<T>* p) {
        if (p != NULL) {
            visit(p);
            inorder(p->left);
            inorder(p->right);
        }
    }
    /************************************************************************/
    /*      前序遍历 非递归实现                                                                */
    /************************************************************************/
    void iterativePreorder(BSTNode<T>* root) {
        stack<BSTNode<T>*> travStack;
        BSTNode<T>* p = root;
        if (p != NULL) {
            travStack.push(p);
            while (!travStack.empty())
            {
                p = travStack.pop();
                visit(p);
                if (p->right != 0) {
                    travStack.push(p->right);
                }
                if (p->left != 0) {
                    travStack.push(p->left);
                }
            }
        }
    }
    //后序遍历
    void postorder(BSTNode<T>* p) {
        if (p != NULL) {
            inorder(p->left);
            inorder(p->right);
            visit(p);
        }
    }

    /************************************************************************/
    /* 后序遍历 非递归实现                                                                     */
    /************************************************************************/
    void iterativePostorder(BSTNode<T>* root) {
        stack<BSTNode<T>*> travStack;
        BSTNode<T>  *p = root, *q = root;
        while (p != 0){
            for (;p->left != 0;p = p->right) {
                travStack.push(p);
            }
            while (p != 0 && (p->right == 0) || p->right == q) {
                visit(p);
                q = p;
                if (travStack.empty()) {
                    return;
                }
                p = travStack.pop();
            }
            travStack.push(p);
            p = p->right;
        }
    }
};

一般来讲，递归效率不是很好，尽量采用非递归形式~~