二叉树的三种非递归遍历（leetcode）

一、前序遍历

前序遍历的思想是：根左右

1.根节点1让自己存起来再去找左子树，根节点的左节点不存在，所以指向他的右节点；

2.节点2先存自己然后指向他的左节点，左节点存在，存入左节点，而且左节点没有孩子节点，所以再指向右节点，右节点不存在，直接返回

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*>s;
        if(root == nullptr)
            return result;
        TreeNode* tmp = nullptr;
        s.push(root);
        while(!s.empty())
        {
            tmp = s.top();
            s.pop();
            result.push_back(tmp->val);
            if(tmp->right)
                s.push(tmp->right);
            if(tmp->left)
                s.push(tmp->left);
        }
        return result;
        }
};

二、中序遍历

中序遍历的思想是：左根右

1.从根节点1出来，发现左节点不存在，存入根节点

2.存入根节点之后指向右节点，右节点存在左孩子节点，左孩子节点无孩子节点，存入左孩子节点之后返回节点2，存入节点2，

3.再指向右节点，右节点不存在，返回。

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

三、后序遍历

后序遍历思想是：左右根

1.根节点1出来，发现左节点不存在，则指向右节点

2.右节点2有孩子节点，先指向左孩子节点3，节点没有孩子节点，则存入节点3，节点3没有孩子节点，然后返回至节点2，

3.节点2没有右孩子节点，存入节点2，再返回至根节点1，存入节点1.

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int>res;
        if(root == nullptr)
            return res;
        stack<TreeNode*>s;
        s.push(root);
        while(!s.empty())
        {
            TreeNode* tmp = s.top();
            s.pop();
            res.push_back(tmp->val);
            if(tmp->left)
                s.push(tmp->left);
            if(tmp->right)
                s.push(tmp->right);
        }
        int l = 0;
        int r = res.size() - 1;
        while(l < r)
        {
            swap(res[l], res[r]);
            ++l;
            --r;
        }
        return res;
    }
};

前序遍历：ABCDEFGHIJK

中序遍历：DCEBGFAJIHK

后序遍历：DECGFBJIKHA