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

Posted 2022-11-15 悟空很开心

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

//记法：根节点的遍历顺序就是树的遍历顺序
    /************************************************************************/
    // 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;
        
    
;

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