二叉树的前序,中序,后续遍历

领扣题目：
https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

二叉树的前序遍历：
非递归写法—利用栈来实现树的遍历

/**
 * 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)
    {
        stack<TreeNode*>s;//栈表示遍历
        vector<int>result;//储存前序遍历的结果
        TreeNode*p;
        if(root!=NULL)
        {
            while(!s.empty()||root!=NULL)//当栈不为空或者此时结点不为空
            {
                if(root!=NULL)
                {
                    s.push(root);//前序遍历-根左右，将根结点压入栈
                    result.push_back(root->val);//根结点值
                    root=root->left;//往左遍历
                }
                else
                {
                    p=s.top();//利用栈后进先出的性质，取出结点
                    s.pop();
                    root=p->right;//往右遍历
                }
            }
            return result;
        }
        return {};

    }
};

递归–没什么好说的，根左右递归就完事了，因为毫无内涵，接下的递归也不讲了

/**
 * 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
{
private:
    vector<int>result;
public:
    vector<int> preorderTraversal(TreeNode* root)
    {
        if(root!=NULL)
        {
            digui(root);
        }
        return result;
    }
    void digui(TreeNode*p)
    {
        if(p==NULL)
            return;
        result.push_back(p->val);
        digui(p->left);
        digui(p->right);
    }
};

中序遍历和前序遍历差不多，只有答案压入时机不同
关键代码

while(!S.empty()||root!=NULL)
{
    if(root!=NULL)
    {
        S.push(root);
        root=root->left;
    }
    else
    {
        p=S.top();
        S.pop();
        result.push_back(p->val);
        root=p->right;
    }

}

后续遍历
非递归,解释看具体代码

/**
 * 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> postorderTraversal(TreeNode* root) {
       vector<int>result;
        stack<TreeNode*>s;
        TreeNode*p;
        p=root;
        while(p)//先一直遍历左子树到底
        {
            s.push(p);
            p=p->left;
        }
        TreeNode*pre=NULL;//记录上一个遍历的结点
        while(!s.empty())
        {
            p=s.top();
            if(p->right==pre||p->right==NULL)//核心
            {//如果此时结点的右节点遍历过或者为空，那么此时应输出此时结点
                s.pop();
                result.push_back(p->val);
                pre=p;
            }
            else
            {
                p=p->right;//走右节点
                while(p)//一直遍历左子树
                {
                    s.push(p);
                    p=p->left;
                }
            }
        }
        return result;
    }
        
};