[基本算法] 二叉树遍历方法

二叉树的遍历包括前序、中序、后序、层次遍历。实现方式一般为递归和循环两种。

接下来给出遍历算法代码，均使用C++编写。

---

 

二叉树结点

使用leetcode常见的TreeNode

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

 

先序遍历

先访问根节点，然后访问左子树，最后访问右子树。

递归版本

void preOrder(TreeNode *root){
    if(root!=nullptr){
        cout<<root->val<<endl;
        preOrder(root->left);
        preOrder(root->right);
    }
}

非递归版本一，将左右子节点压入栈中，下一次弹出栈顶进行遍历：

void preOrderLoop(TreeNode *root){
    stack<TreeNode*> stk;
    stk.push(root);

    TreeNode *p;
    while(!stk.empty()){
        p=stk.top();
        stk.pop();

        if(p==nullptr)
            continue;

        cout<<p->val<<endl;
        stk.push(p->right);
        stk.push(p->left);
    }
}

非递归版本二，遍历左节点之前将子节点压入栈中，当碰到nullptr时弹出栈顶，从其右子节点开始遍历：

（栈中保存的是可能还没访问右子节点的节点）

void preOrderLoop2(TreeNode *root){
    stack<TreeNode*> stk;
    TreeNode *p=root;

    while(p!=nullptr || !stk.empty()){
        while(p!=nullptr){
            cout<<p->val<<endl;
            // 将根节点压入栈中，便于之后遍历右子树
            stk.push(p);
            p=p->left;
        }
        // 若p为null，则从栈中取出节点访问其右节点
        if(!stk.empty()){
            p=stk.top();
            stk.pop();
            p=p->right;
        }
    }
}

 

中序遍历

 先访问左子树，然后访问根节点，最后访问右子树

递归版本

void inOrder(TreeNode *root){
    if(root!=nullptr){
        inOrder(root->left);
        cout<<root->val<<endl;
        inOrder(root->right);
    }
}

非递归版本，遍历节点时不先访问值，而是将节点存入栈中，然后继续访问左节点。

当遍历的节点为空时，从栈中弹出节点，访问值并继续访问右节点。

void inOrderLoop(TreeNode *root){
    stack<TreeNode*> stk;
    TreeNode *p=root;
    while(p!=nullptr || !stk.empty()){
        while(p!=nullptr){
            stk.push(p);
            p=p->left;
        }
        // 当p==nullptr，则左子树已完全访问，应访问根节点和右子树
        if(!stk.empty()){
            p=stk.top();
            stk.pop();
            cout<<p->val<<endl;
            p=p->right;
        }
    }
} 

上面的代码有循环嵌套，可以进行简化：

void inOrderLoop2(TreeNode *root){
    stack<TreeNode*> stk;
    TreeNode *p=root;
    while(p!=nullptr || !stk.empty()){
        if(p!=nullptr){
            stk.push(p);
            p=p->left;
        }
        else{
            p=stk.top();
            stk.pop();
            cout<<p->val<<endl;
            p=p->right;
        }
    }
}

 

 

后序遍历

先访问左子树，然后访问右子树，最后访问根节点

递归版本

void postOrder(TreeNode *root){
    if(root!=nullptr){
        postOrder(root->left);
        postOrder(root->right);
        cout<<root->val<<endl;
    }
}

非递归版本，使用lastVisit保存上次访问的右节点，若从栈中弹出的节点右节点为空或为上次访问的节点，则访值：

void postOrderLoop(TreeNode *root){
    stack<TreeNode*> stk;
    TreeNode *p=root;
    TreeNode *lastVisit=p;

    while(p!=nullptr || !stk.empty()){
        while(p!=nullptr){
            stk.push(p);
            p=p->left;
        }
        //左子树访问完毕，出栈访问右子树
        p=stk.top();
        //检查是否右子树为空或者已被访问
        if(p->right==nullptr || p->right==lastVisit){
            cout<<p->val<<endl;
            stk.pop();
            lastVisit=p;
            p=nullptr;
        }
        else{
            p=p->right;
        }
    }
}

 

层次遍历

按照二叉树的层次进行遍历，一般是非递归版本：

void levelOrder(TreeNode *root){
    vector<TreeNode*> vec;
    TreeNode *p;
    vec.push_back(root);

    while(vec.size()>0){
        vector<TreeNode*> temp;
        for(TreeNode* v:vec){
            cout<<v->val<<endl;
            if(v->left!=nullptr) temp.push_back(v->left);
            if(v->right!=nullptr) temp.push_back(v->right);
        }
        swap(vec,temp);
    }
}