二叉树的遍历

下面是二叉树的遍历，先序，中序和后序都采用了栈的方式，层序使用的是递归的方式，主要是leecode的要求，二叉树的遍历还是递归容易。

#include <iostream>
#include <vector>
#include <stack>
using std::stack;
using std::vector;

struct TreeNode{
    int val;
    TreeNode* leftNode;
    TreeNode* rightNode;
    TreeNode(int x) : val(x),leftNode(nullptr),rightNode(nullptr) {}
};

class Solution {
public:
    vector<int> preOrderTraversal(TreeNode* root) {
        vector<int> res = {};
        stack<TreeNode*> s;
        if(root)  s.push(root);
        TreeNode* p;
        while(!s.empty())
        {
            p = s.top();
            res.push_back(p->val);
            s.pop();
            if(p->rightNode)  s.push(p->rightNode);
            if(p->leftNode) s.push(p->leftNode);  
        }
        return res;
    }

    vector<int> inOrderTraversal(TreeNode* root)
    {
        vector<int> res = {};
        stack<TreeNode*> s;
        TreeNode* p = root;
        while(!s.empty() || p)
        {
            if(p)
            {
                s.push(p);
                p= p->leftNode;
            }
            else
            {
                p = s.top();
                res.push_back(p->val);
                s.pop();
                p = p->rightNode;
            }
        }
        return res;
    }

    vector<int> postOrderTraversal(TreeNode* root)
    {
        vector<int> res = {};
        stack<TreeNode*> s;
        TreeNode* p = root; //being access
        TreeNode* q = nullptr; //previous access

        do{
            while(p)
            {
                s.push(p);
                p = p->leftNode;
            }
            q = nullptr;
            while(!s.empty())
            {
                p = s.top();
                s.pop();
                if(p->rightNode == q)
                {
                    res.push_back(p->val);
                    q = p;
                }
                else
                {
                    s.push(p);
                    p = p->rightNode;
                    break;
                }
            }
        }while(!s.empty());
        return res;
    }

    vector<vector<int>> levelOrderTraversal(TreeNode* root)
    {
        vector<vector<int>> res;
        if(!root) return res;
        levelOrderTraversalCore(root,1,res);
        return res;
    }
private:
    void levelOrderTraversalCore(TreeNode* root,int level,vector<vector<int>>& res)
    {
        if(!root) return;
        if(level > res.size()) 
            res.push_back(vector<int>());
        res[level-1].push_back(root->val);
        levelOrderTraversalCore(root->leftNode,level+1,res);
        levelOrderTraversalCore(root->rightNode,level+1,res);
    }
};