【LeetCode | 二叉树前、中、后序遍历{递归法}实现】

1.前序遍历

题目 题目.jpg 题目.jpg

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;


struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(): val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}
};


// 前序遍历:根左右
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root, result);
        return result;
    }
    
    // 1.确定函数入参
    void Traversal(TreeNode* node, vector<int>& vec)
    {
        // 2.确定递归终止条件
        if(node == nullptr) return ;

        // 3.确定单层递归逻辑代码
        vec.push_back(node->val);
        Traversal(node->left, vec);
        Traversal(node->right, vec);
    }
};

2.中序遍历

题目 题目.jpg 题目.jpg

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;


struct TreeNode{
   int val;
   TreeNode* left;
   TreeNode* right;
   TreeNode(): val(0), left(nullptr), right(nullptr) {}
   TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
   TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}
};


// 中序遍历:左根右
class Solution {
public:
   vector<int> inorderTraversal(TreeNode* root) {
       vector<int> result;
       Traversal(root, result);
       return result;
   }
   
   // 1.确定函数入参
   void Traversal(TreeNode* node, vector<int>& vec)
   {
       // 2.确定递归终止条件
       if(node == nullptr) return ;

       // 3.确定单层递归逻辑代码
       Traversal(node->left, vec);
       vec.push_back(node->val);
       Traversal(node->right, vec);
   }
};

3.后序遍历

题目.jpg

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;


struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(): val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}
};


// 后序遍历:左右根
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root, result);
        return result;
    }
    
    // 1.确定函数入参
    void Traversal(TreeNode* node, vector<int>& vec)
    {
        // 2.确定递归终止条件
        if(node == nullptr) return ;

        // 3.确定单层递归逻辑代码
        Traversal(node->left, vec);
        Traversal(node->right, vec);
        vec.push_back(node->val);
    }
};