二叉树前序遍历，中序遍历，后序遍历以及层次遍历实现

一、二叉树的层次遍历

　　1. 非递归实现：利用队列，存储每一层次的结点进队列，再通过出队操作完成层次遍历。

代码：

/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == NULL)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int qnum = q.size();
            vector<int> cur;
            for(int i=0; i<qnum; i++)
            {
                TreeNode* tmp = q.front();
                q.pop();
                cur.push_back(tmp->val);
                if(tmp->left)
                    q.push(tmp->left);
                if(tmp->right)
                    q.push(tmp->right);
            }
            res.push_back(cur);
        }
        return res;
    }
};

2. 递归实现：这里的递归用到了搜索中的bfs。递归函数中需要一个level参数，来确定当前的访问层级。若当前的层级大于等于res数组中的总大小，说明到达新层，需要添加新层。

代码：

/**
 * 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:
    void levelOrderCore(TreeNode* cur, int level, vector<vector<int>>& res)
    {
        if(!cur)
            return;
        if(level >= res.size())
        {
            res.push_back(vector<int>{});
        }
        res[level].push_back(cur->val);
        levelOrderCore(cur->left, level+1, res);
        levelOrderCore(cur->right, level+1, res);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == NULL)
            return res;
        levelOrderCore(root, 0, res);
        return res;
    }
};

二、前序遍历

1. 非递归实现：借用栈来完成，首先根结点入栈，接下来开始清空栈，对于当前栈顶结点，先入栈右子树，再入栈左子树，这样就可以保证总是先存储左子树，再存储右子树。

代码：

/**
 * 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;
        s.push(root);
        while(!s.empty())
        {
            TreeNode* tmp = s.top();
            s.pop();
            res.push_back(tmp->val);
            if(tmp->right)
            {
                s.push(tmp->right);
            }
            if(tmp->left)
            {
                s.push(tmp->left);
            }
        }
        return res;
    }
};

2. 递归实现：DFS

/**
 * 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:
    void preorderCore(TreeNode* cur, vector<int>& res)
    {
        if(!cur)
            return;
        res.push_back(cur->val);
        preorderCore(cur->left, res);
        preorderCore(cur->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        preorderCore(root, res);
        return res;
    }
};

三、中序遍历

1. 非递归实现：同样利用栈来实现。首先将根结点入栈，再循环将当前结点的左指针入栈，这样保证了栈顶为最左的结点。接下来清空栈的过程中，将当前栈顶的值保存，同时判断其是否存在右子树，若存在，右子树继续之前循环左指针入栈的操作，保证了当前树的中序遍历。

代码：

/**
 * 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> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode*> s;
        TreeNode* tmp = root;
        s.push(root);
        while(tmp->left)
        {
            s.push(tmp->left);
            tmp = tmp->left;
        }
        while(!s.empty())
        {
            TreeNode* cur = s.top();
            res.push_back(cur->val);
            s.pop();
            if(cur->right)
            {
                cur = cur->right;
                while(cur)
                {
                    s.push(cur);
                    cur = cur->left;
                }
            }
        }       
        return res;
    }
};

2. 递归实现：递归的方法很简单，就是先调用当前结点左子树的中序遍历，再将当前结点加入序列，最后调用当前结点右子树的中序遍历。

代码：

/**
 * 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:
    void inorderCore(TreeNode* cur, vector<int>& res)
    {
        if(!cur)
            return;
        inorderCore(cur->left, res);
        res.push_back(cur->val);
        inorderCore(cur->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        inorderCore(root, res);
        return res;
    }
};

四、后序遍历

1. 非递归实现：同样利用栈，由于后序遍历的顺序是左右根，可以利用根右左来逆序输出。根右左和前序遍历非常相近，因此只需要改部分代码即可实现。

代码：

/**
 * 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> res;
        if(root == NULL)
            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);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

2. 递归实现：根据之前的前序遍历和中序遍历，递归的后序版本也十分简单。先遍历左子树，再遍历右子树，最后将根结点的值保存。

代码：

/**
 * 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:
    void postorderCore(TreeNode* cur, vector<int>& res)
    {
        if(!cur)
            return;
        postorderCore(cur->left, res);
        postorderCore(cur->right, res);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        postorderCore(root, res);
        return res;
    }
};