二叉树的前中序遍历 递归和迭代

递归

vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        //递归实现
        preorder(root, result);
        return result;
    }
    void preorder(TreeNode* root, vector<int>& result){
        if(root == nullptr) return;
        result.push_back(root->val)； 
        preorder(root->left, result);
        preorder(root->right, result);
    }

迭代

vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        //迭代实现
        stack<TreeNode*> s;
        TreeNode* now = root;
        while(now != nullptr || !s.empty()){
            while(now){
                result.push_back(now->val);
                s.push(now);
                now = now->left;
            }
            //弹出访问右子树
            now = s.top();
            now = now->right;
            s.pop();
        }    
        return result;
    }

递归

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        //递归方案
        inorder(root, result);
        return result;
    }
    void inorder(TreeNode* root, vector<int>& result){
        if(root == nullptr) return;
        inorder(root->left, result);
        result.push_back(root->val);
        inorder(root->right, result);
    }

迭代

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> s;
        TreeNode* now = root;
        while(now!=nullptr||!s.empty()){
            while(now!=nullptr){
                s.push(now);
                now = now->left;
            }
            now = s.top();
            result.push_back(now->val);
            s.pop();
            now = now->right;
        }
        return result;
    }

vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        postorder(root,result);
        return result;
    }
    void postorder(TreeNode* node, vector<int>& result){
        if(node == nullptr) return;
        postorder(node->left,result);
        postorder(node->right,result);
        result.push_back(node->val);
    }

 vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> s;
        TreeNode* now = root; 
        TreeNode* pre = nullptr;
        while (now != nullptr || !s.empty()) {
            while (now != nullptr) {
                s.push(now);
                now = now->left;
            }
            now = s.top();
            if (now->right == nullptr || now->right == pre) {  //没有右孩子或者已经遍历了右孩子
                result.push_back(now->val);
                s.pop();
                pre = now;
                now = nullptr;
            } else {
                now = now->right;
            }
        }
        return result;
    }

或
 vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        TreeNode* now = root;
        TreeNode* pre = nullptr;
        while(now!=nullptr || !s.empty()){
            if(now != nullptr){
                s.push(now);
                now = now->left;
            }else{
                now = s.top();
                if(now->right == nullptr || now->right == pre){  //当now->right == nullptr时说明是叶子节点
                    result.push_back(now->val);                  //当now->right == pre 说明是上一轮是从右子节点退出的，那说明要将当前节点值输出
                    pre = now;                                   //pre记录上一轮访问节点
                    s.pop();
                    now = nullptr;
                }else{                                           //有右孩子 或者 now->left == pre 即为访问过左孩子，下一步访问右孩子
                    //now = now->right;
                }
            }
        }
        return result;
    }

关于二叉数的相关题目，还可以参考剑指Offer中第8题 二叉树的下一个节点。