二叉树的前序，中序，后序，层序遍历（对应Leetcode）

C++实现二叉树的前序，中序，后序，层序遍历（对应Leetcode144，94，145，102题)

记录C++实现二叉树的几种遍历方式，包括递归和非递归方式。话不多说，直接上代码

一、二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

 //1.递归
class Solution 
{
public:
    vector<int> res;
    vector<int> preorderTraversal(TreeNode* root) 
    {
        if(root != NULL)
        {
            res.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return res;
    }
};

//2.1 非递归1
class Solution
{
public:
	vector<int> preorderTraversal(TreeNode* root)
	{
		vector<int> res;
		stack<TreeNode*> s;
		TreeNode* curr = root;
		while (curr || !s.empty())
		{
			if (curr)//遍历左树，结点入栈，值入vector
			{
				res.push_back(curr->val);
				s.push(curr);
				curr = curr->left;
			}
			else //左树为空，向右树转
			{
				curr = s.top();
				s.pop();
				curr = curr->right;
			}
		}
		return res;
	}
};
//2.2 非递归2
class Solution
{
public:
    vector<int> preorderTraversal(TreeNode* root)
    {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode* curr = root;
        while(curr != NULL || !s.empty())
        {
            while(curr!=NULL)
            {
            	res.push_back(curr->val);
            	s.push(curr);
            	curr = curr->left;
            }
            	curr = s.top();
            	s.pop();
            	curr = curr->right;
    }
        return res;
    }
};

二、二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//1.递归 
//时间复杂度：O(n)O(n)，递归函数 T(n) = 2⋅T(n/2)+1。
//空间复杂度：最坏情况下需要空间O(n)(树退化为链表时)，平均情况为O(logn)。
class Solution 
{
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) 
    {
        if(root)
        {
            inorderTraversal(root->left);
            res.push_back(root->val);
            inorderTraversal(root->right);
        }
        return res;
    }
};
//2.非递归 时间复杂度O(n),空间复杂度O(n)
class Solution{
public:
    vector<int> inorderTraversal(TreeNode* root)
    {
        stack<TreeNode*> s;
        vector<int> res;
        TreeNode* curr = root;
        while(curr != NULL || !s.empty())
        {
            while(curr!=NULL)
            {
                s.push(curr);
                curr = curr->left;
            }
            curr = s.top();
            s.pop();
            res.push_back(curr->val);
            curr = curr->right;
        }
        return res;
    }
};

三、二叉树的后序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//1.递归
class Solution 
{
public:
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) 
    {
        if(root)
        {
            postorderTraversal(root->left);
            postorderTraversal(root->right);
            res.push_back(root->val);
        }
        return res;
    }
};
//2.非递归
class Solution
{
public:
    vector<int> postorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*> s;
        vector<int> res;
        TreeNode* curr = root;
        TreeNode* pre = NULL;
        while(curr || !s.empty())
        {
            while(curr)
            {
                s.push(curr);
                curr = curr->left;
            }
            curr = s.top();
            if(curr->right == NULL || pre == curr->right)
            {
                s.pop();
                res.push_back(curr->val);
                pre = curr;
                curr = NULL;
            }
            else
            {
                curr = curr->right; 
            }
        }
        return res;
    }
};

四、二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //借助辅助队列，BFS实现
class Solution 
{
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        if(root == NULL) return{};
        vector<vector<int>> res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            vector<int> level;//存储当前层的结点
            int count = q.size();
            while(count--)
            {
                TreeNode* tmp = q.front();
                q.pop();
                level.push_back(tmp->val);
                if(tmp->left)
                {
                    q.push(tmp->left);
                }
                if(tmp->right)
                {
                    q.push(tmp->right);
                }
            }
            res.push_back(level);
        } 
        return res;
    }
};