代码随想录算法训练营第13天 |二叉树遍历

C++的二叉树定义：

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) {}
};

经常用到的递归：（来源：代码随行录）

递归算法的三个要素。每次写递归，都按照这三要素来写

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

 二叉树递归遍历（前中后）：

class Solution {
public:
    // 前序遍历, 到我就记录我
    void preorderTraversal(TreeNode* root, vector<int>& vec){
        if(root == nullptr) return;
        vec.push_back(root->val);
        preorderTraversal(root->left, vec);
        preorderTraversal(root->right, vec);
    }
    // 后序遍历，把我的左右记录完了再来记录我
    void postorderTraversal(TreeNode* root, vector<int>& vec){
        if(root == nullptr) return;
        postorderTraversal(root->left, vec);
        postorderTraversal(root->right, vec);
        vec.push_back(root->val);
    }
    // 中序遍历，记录完左边后就记录我
    void inorder(TreeNode* r, vector<int>& res) {
        if (root == nullptr) {
            return;
        }
        inorder(r->left, res);
        res.push_back(r->val);
        inorder(r->right, res);
    };
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        preorderTraversal(root, ans);
        return ans;
    }
};

二叉树迭代遍历：

前：

class Solution {
public:
    // 迭代, 前序特点，我比子节点先（前中后有区别），左比右节点先（这个好像都是这样）
    // 入栈顺序：右节点-左节点
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root == NULL){
            return ans;
        }
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* node = stk.top(); 
            stk.pop();
            ans.push_back(node->val);
            if(node->right){
                stk.push(node->right);
            }
            if(node->left){
                stk.push(node->left);
            }
        }
        return ans;
    }   
};

中：

    // 迭代，中序遍历，我比左节点晚，比右节点早
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root == nullptr){
            return ans;
        }
        stack<TreeNode*> stk;
        TreeNode* node = root;
        while(node != nullptr || !stk.empty()){
            if(node != nullptr){
                stk.push(node);
                node = node->left;
            }else{
                TreeNode* last = stk.top(); // 左节点遍历完了，退一级
                stk.pop();
                ans.push_back(last->val);
                node = last->right; 
            }
        }
        return ans;
    }

后序遍历

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        if (root == NULL){
            return ans;
        }
        stack<TreeNode*> stk;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            stk.pop();
            ans.push_back(node->val);
            if (node->left) {
                stk.push(node->left); 
            }        
            if (node->right) stk.push(node->right); 
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }

层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(!root){
            return ans;
        }
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int q_size = q.size(); // 这一层的数量
            vector<int> ans_s;
            for(int i = 0; i < q_size; i++){  // 将同一层的节点全部录入
                TreeNode* node = q.front();
                ans_s.push_back(node->val);
                q.pop();
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            ans.push_back(ans_s);
        }
        return ans;
    }
};

递归

class Solution {
public:
    void levelOrder(TreeNode* node, vector<vector<int>>& ans, int depth){
        if(node == nullptr){
            return ;
        }
        if(ans.size() < depth){
            ans.push_back(vector<int>()); // 保持当前数组长度与深度一致
        }
        ans[depth - 1].push_back(node->val);
        levelOrder(node->left, ans, depth + 1);
        levelOrder(node->right, ans, depth + 1);  // 先左后右
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        levelOrder(root, ans, 1);
        return ans;
    }
};