二叉樹的前序，中序，後序，層序遍歷（對應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;
    }
};