【leetcode题解C++】144. 94. 145.二叉树前序、中序、后序遍历 and 102.二叉树的层序遍历

144. 二叉树前序遍历

给出一个根节点，返回前中后序遍历的结果的。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

思路1：递归调用。剩余两种遍历的代码实现参照一下即可。

代码实现1：

/**
 * Definition for a binary tree node.
 * 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:
    void traversal(TreeNode *cur, vector<int> &vec) {
        if(cur == nullptr) return;
        vec.push_back(cur->val);      //根
        traversal(cur->left, vec);    //左
        traversal(cur->right, vec);   //右
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        traversal(root, ret);
        return ret;
    }
};

思路2：迭代，用到了栈，因为是先入后出的，所以先入右孩子结点（后序遍历的话就是把入栈顺序修改一下）。中序遍历就会有所不同，下面会说到。

代码实现2：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {    //前序
        stack<TreeNode *> stk;
        vector<int> ret;
        if(root == nullptr) return ret;
        stk.push(root);
        while(!stk.empty()) {
            TreeNode *node = stk.top();
            stk.pop();
            ret.push_back(node->val);
            if(node->right) stk.push(node->right);  //右
            if(node->left) stk.push(node->left);    //左
        }
        return ret;
    }
};

中序：首先需要明确的是，需要一直深入左孩子结点，然后才是中间结点和右孩子结点，那么用一个指针来遍历，也是用栈的思想。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode *> stk;
        vector<int> ret;
        TreeNode *cur = root;
        while(cur != nullptr || !stk.empty()) {
            if(cur != nullptr) {
                stk.push(cur);
                cur = cur->left;
            }
            else {
                cur = stk.top();
                stk.pop();
                ret.push_back(cur->val);
                cur = cur->right;
            }
        }
        return ret;
    }
};

102 .二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

思路：一层一层处理，每一层装入一个vector，然后把每一层装入二维数组。

代码实现：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode *> que;
        vector<vector<int>> ret;
        if(root == nullptr) return ret;
        que.push(root);
        TreeNode * node;
        while(!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; ++i) {
                node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right); 
            }
            ret.push_back(vec);
        }
        return ret;
    }
};

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]
输出：[2,3,1]

示例 3：

输入：root = []
输出：[]

思路：实现的方式有很多，把每一个结点的左右孩子结点做一个swap。上面刚做完层序遍历，那么就用层序遍历来实现。

代码实现：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode *> que;
        if(root != nullptr) que.push(root);
        TreeNode *node;
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; ++i) {
                node = que.front();
                que.pop();
                if(node -> right || node -> left) {
                    swap(node -> left, node -> right); 
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};