二叉树的三种遍历C++ 从简入模板

前序遍历

递归

void preorder(TreeNode *root, vector<int> &path)
{
    if(root != NULL)
    {
        path.push_back(root->val);
        preorder(root->left, path);
        preorder(root->right, path);
    }
}

非递归前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        stack<TreeNode*> s;
        TreeNode* node = root;
        while(node != NULL || !s.empty()){
            if(node != NULL){
                res.push_back(node->val);
                s.push(node);
                node = node->left;
            }else{
                node = s.top();
                s.pop();
                node = node->right;
            }
        }
        return res;
    }
};

更简单的非递归前序遍历

void preorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root->right, false));
            s.push(make_pair(root->left, false));
            s.push(make_pair(root, true));
        }
    }
}

中序遍历

递归

void inorder(TreeNode *root, vector<int> &path)
{
    if(root != NULL)
    {
        inorder(root->left, path);
        path.push_back(root->val);
        inorder(root->right, path);
    }
}

非递归

class Solution {
public:
    vector<int>res;
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == NULL)
            return {};
        TreeNode* node = root;
        stack<TreeNode*>s;
  
        while(!s.empty() || node!= NULL){
            if(node != NULL){
                s.push(node);
                node = node->left;
            }else{
                node = s.top();
                s.pop();
                res.push_back(node->val);
                node = node->right;
            }
        }
        return res;
    }
};

更简单的非递归中序遍历

void inorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root->right, false));
            s.push(make_pair(root, true));
            s.push(make_pair(root->left, false));
        }
    }
}

后续遍历

递归

void postorder(TreeNode *root, vector<int> &path)
{
    if(root != NULL)
    {
        postorder(root->left, path);
        postorder(root->right, path);
        path.push_back(root->val);
    }
}

非递归

class Solution {
public:
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == NULL)
            return {};
        stack<TreeNode*> s;
        TreeNode* node = root;
        TreeNode* lastNode = root;//需要记录上一个访问节点
        s.push(root);
        while(!s.empty()){
            node = s.top();
            if((node->left == NULL && node->right == NULL) || node->left == lastNode || node->right == lastNode){
                res.push_back(node->val);
                s.pop();
                lastNode = node;
            }else{
                if(node->right)
                    s.push(node->right);
                if(node->left)
                    s.push(node->left);
            }
        }
       return res; 
    }
};

更简单的非递归后序遍历

void postorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root, true));
            s.push(make_pair(root->right, false));
            s.push(make_pair(root->left, false));
        }
    }
}