二刷代码随想录训练营Day 13| 理论基础、递归遍历、迭代遍历、统一迭代、层序遍历

于 2024-07-29 14:11:48 发布
阅读量419 收藏 5
点赞数 5
文章标签： c++ leetcode 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_64434454/article/details/140764978
版权

1.理论基础

代码随想录

2.递归遍历

144. 二叉树的前序遍历 - 力扣（LeetCode）
145. 二叉树的后序遍历 - 力扣（LeetCode）
94. 二叉树的中序遍历 - 力扣（LeetCode）

代码：（前序遍历）中左右 

class Solution {
public:
    void traversal(TreeNode* node,vector<int>& result){
        if(node == NULL) return;
        result.push_back(node->val);
        traversal(node->left,result);
        traversal(node->right,result);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

代码：（中序遍历）左中右

class Solution {
public:
    void traversal(TreeNode* node,vector<int>& result){
        if(node == NULL) return;
        traversal(node->left,result);
        result.push_back(node->val);
        traversal(node->right,result);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

 代码：（后序遍历）左右中

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& result){
        if(node == NULL) return;
        traversal(node->left,result);
        traversal(node->right,result);
        result.push_back(node->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

3.迭代遍历

144. 二叉树的前序遍历 - 力扣（LeetCode）
145. 二叉树的后序遍历 - 力扣（LeetCode）
94. 二叉树的中序遍历 - 力扣（LeetCode）

前序：（用了栈 顺序要反一下） 

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

后序

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
         vector<int> result;
        stack<TreeNode*> st;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            if(node == NULL) continue;
            result.push_back(node->val);
            // 左
            st.push(node->left);
            // 右
            st.push(node->right);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

 note：在前序的基础上改了左右的顺序，同时最后再来个数组的翻转。

中序：

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

4.统一迭代

144. 二叉树的前序遍历 - 力扣（LeetCode）
145. 二叉树的后序遍历 - 力扣（LeetCode）
94. 二叉树的中序遍历 - 力扣（LeetCode）

note:使用栈进行遍历的时候，要记得栈是先进后出，因此顺序得反一下 

代码：前序遍历 

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

代码：中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node != NULL){
                st.pop();
                // 右
                if(node->right != NULL) st.push(node->right);
                // 中
                st.push(node);
                st.push(nullptr);
                // 左
                if(node->left != NULL) st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

 代码：后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root != NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node != NULL){
                // 中
                st.pop();
                st.push(node);
                st.push(nullptr);
                // 右
                if(node->right != NULL) st.push(node->right);
                // 左
                if(node->left != NULL) st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

5.层序遍历

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

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> cur;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                cur.push_back(node->val);
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            result.push_back(cur);
        }
        return result;
    }
};

 相关题目练习

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            vector<int> cur;
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                cur.push_back(node->val);
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            result.push_back(cur);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

note:最后把数组翻转一下就好了 

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(size == 0) result.push_back(node->val);
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
        }
        return result;
    }
};

note:size是判断后进行--才进入循环的，因此应该是判断条件为size==0的时候收集结果 

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            double tmp = sum / size;
            result.push_back(tmp);
        }
        return result;
    }
};

note：sum是double类型 

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> cur;
            while(size--){
                Node* node = que.front();
                que.pop();
                cur.push_back(node->val);
                for(int i = 0; i < node->children.size();i++){
                    if(node->children[i] != NULL) que.push(node->children[i]);
                }
            }
            result.push_back(cur);
        }
        return result;
    }
};

note:注意题上给的结构体是Node不是TreeNode

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int maxNum = INT_MIN;
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                maxNum = max(maxNum,node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(maxNum);
        }
        return result;
    }
};
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root != NULL){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size != 0){
                    node->next = que.front();
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

note:只要不是该层最后一个结点，就让当前遍历的结点指向队列里的下一个结点 

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root != NULL){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            while(size--){
                Node* node = que.front();
                que.pop();
                if(size != 0){
                    node->next = que.front();
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

note：和上题一样 

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int result = 0;
        queue<TreeNode*> que;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            result++;
        }
        return result;
    }
};

note:对有多少个里循环计数 

class Solution {
public:
    int minDepth(TreeNode* root) {
        int result = 0;
        queue<TreeNode*> que;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            result++;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
                if(node->left == NULL && node->right == NULL){
                    return result;
                }
            }
        }
        return result;
    }
};

note:只有当左右孩子都为空的时候才能收获结果

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值