代码随想录训练营第13天|中序遍历指针迭代

已于 2024-09-04 13:58:46 修改
阅读量204 收藏 4
点赞数 8
文章标签： 算法
于 2024-08-26 11:07:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiyisuifeng1991/article/details/141547895
版权

144. 二叉树的前序遍历

/**
 * 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<int> res;
    void preTraversal(TreeNode* root){
        if(root==nullptr)
            return;
        res.push_back(root->val);
        preTraversal(root->left);
        preTraversal(root->right);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        preTraversal(root);
        return res;        
    }
};
/**
 * 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<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==nullptr)
            return {};
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            auto cur=st.top();
            st.pop();
            res.push_back(cur->val);
            if(cur->right)
                st.push(cur->right);
            if(cur->left)
                st.push(cur->left);
        }
        return res;        
    }
};

145.二叉树的后序遍历

/**
 * 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<int> res;

    void postTraversal(TreeNode* root){
        if(root==nullptr)
            return;
        postTraversal(root->left);
        postTraversal(root->right);
        res.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        postTraversal(root);
        return res;
    }
};
/**
 * 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<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        //根->右->左
        stack<TreeNode*> st;
        if(root==nullptr)
            return res;
        st.push(root);
        while(!st.empty()){
            auto cur=st.top();
            st.pop();
            res.push_back(cur->val);
            if(cur->left)
                st.push(cur->left);
            if(cur->right)
                st.push(cur->right);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

94. 二叉树的中序遍历

/**
 * 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<int> res;

    void inorder(TreeNode* root){
        if(root==nullptr)
            return;
        inorder(root->left);
        res.push_back(root->val);
        inorder(root->right);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        if(root==nullptr)
            return {};
        inorder(root);
        return res;
    }
};
/**
 * 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<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode *cur=root;
        while(!st.empty()||cur){
            if(cur){
                st.push(cur);
                cur=cur->left;
            }
            else{
                auto node=st.top();
                st.pop();
                res.push_back(node->val);
                cur=node->right;
            }
            
        }
        return res;
    }
};

使用cur指针访问到树最左（【处理左】），用stack记录过程节点，当cur为空时，回溯上一节点，收集结果（【处理根】），再将cur指向右孩子（【处理右】），实现中序遍历。

102. 二叉树的层序遍历

/**
 * 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>> res;
        if(root==nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            vector<int> level;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                level.push_back(node->val);
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            res.push_back(level);
        }
        return res;
    }
};

199. 二叉树的右视图

/**
 * 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<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root==nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
                if(i==n-1)
                    res.push_back(node->val);
            }
        }
        return res;
    }
};

 637. 二叉树的层平均值

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            double sum=0;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                sum+=node->val;
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            res.push_back(sum/n);
        }
        return res;
    }
};

429. N 叉树的层序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        if(root==nullptr)
            return res;
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            vector<int> level;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                level.push_back(node->val);
                for(auto child:node->children){
                    if(child)
                        q.push(child);
                }
            }
            res.push_back(level);
        }
        return res;
    }
};

515. 在每个树行中找最大值

/**
 * 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<int> largestValues(TreeNode* root) {
        vector<int> res;
        if(root==nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            int max_val=INT_MIN;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                max_val=max(max_val,node->val);
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            res.push_back(max_val);
        }
        return res;
    }   
};

116. 填充每个节点的下一个右侧节点指针

/*
// 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) {
        if(root==nullptr)
            return nullptr;
        queue<Node*> q;

        q.push(root);
        while(!q.empty()){
            int n=q.size();
            Node *pre=nullptr;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                if(pre){
                    pre->next=node;
                }
                pre=node;
                if(i==n-1)
                    node->next=nullptr;
                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);

            }
        }
        return root;
    }
};

104. 二叉树的最大深度

/**
 * 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:
    int maxDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        int left=maxDepth(root->left);
        int right=maxDepth(root->right);
        return 1+max(left,right);
    }
};

111. 二叉树的最小深度

/**
 * 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:
    int minDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        int left=minDepth(root->left);
        int right=minDepth(root->right);
        if(left==0)
            return 1+right;
        if(right==0)
            return 1+left;
        return 1+min(left,right);
    }
};

注意深度的定义，要求到【叶子节点】，而不能到空节点，所以左子树或右子树为空时，要额外处理。

jiyisuifeng1991
关注
代码随想录算法训练营第十三天｜递归遍历 迭代遍历 统一迭代 层序遍历
qq_39981702的博客
07-30 341
更详细的基础理论：代码随想录二叉树理论基础今日主要学习了通过递归法迭代法来获取二叉树的前中后序遍历数据以及层序遍历法来获取二叉树数据，总的来说相比之前熟悉了很多，尤其是层序遍历后边十道题的训练，看到层序遍历的题目能够很快的反应过来。由于二叉树不太熟因此只看了python的，而且统一迭代法也暂时放过了，java的还没来得及看，后边有时间再补上吧。
代码随想录算法训练营第十三天| 递归遍历、迭代遍历、统一迭代、层序遍历
jinshengqile的博客
07-29 231
【代码】代码随想录算法训练营第十三天| 递归遍历、迭代遍历、统一迭代、层序遍历。
代码随想录算法训练营第11天|递归遍历、迭代遍历、统一迭代、层序遍历
summersnowzgq的博客
06-23 755
1.确定递归函数的参数和返回值：2.确定终止条件3.确定单层递归的逻辑针对前中后遍历，递归逻辑基本一致，只是递归的顺序不一致。
代码随想录算法训练营第十四天 | 递归遍历 迭代遍历 统一迭代
weixin_43875669的博客
03-05 448
/中序遍历public:if (root!while (!if (node!// 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中// 添加右节点（空节点不入栈）// 添加中节点// 中节点访问过，但是还没有处理，加入空节点做为标记。// 添加左节点（空节点不入栈）} else { // 只有遇到空节点的时候，才将下一个节点放进结果集st.pop();// 将空节点弹出// 重新取出栈中元素st.pop();// 加入到结果集。
代码随想录算法训练营第十三天|递归遍历 、迭代遍历、 统一迭代
2303_76761642的博客
03-14 116
输入：root = [1,null,2,3]输入：root = [1,null,2]输入：root = [1,2]输入：root = [1]输入：root = []输出：[1,2,3]
代码随想录算法训练营Day13 | 递归遍历、迭代遍历、层序遍历
jiabao0520的博客
09-24 1004
训练营第13天：144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历、102.二叉树的层序遍历、107.二叉树的层序遍历Ⅱ、199.二叉树的右视图、637.二叉树的层平均值、429.N叉树的层序遍历、515. 在每个树行中找最大值、116. 填充每个节点的下一个右侧节点指针、117. 填充每个节点的下一个右侧节点指针 Ⅱ、104.二叉树的最大深度、111.二叉树的最小深度。
代码随想录算法训练营第13天| 二叉树专题——递归遍历 | 迭代遍历 | 统一迭代 | 层序遍历
qq_45077485的博客
07-03 331
递归遍历 | 迭代遍历
代码随想录训练营Day14二叉树|理论基础|递归遍历|迭代遍历|统一迭代
yy19991222的博客
06-22 340
二叉树的种类​，结点数量：2^k-1​，除了底层，其他层是满二叉树，底层从左到右结点连续（堆，就是完全二叉树）​（有序树），左子树小于中间结点，右子树大于中间结点​（有序树），左子树和右子树深度差不超过1（map，set，multimap，multiset底层实现，因此元素有序）二叉树的存储方式​（指针），每个结点有节点元素、两个指针，分别指向左右子节点（常用）；​（数组，有下标和元素），下表ix2+1为左孩子，ix2+2为右孩子。二叉树遍历​。
代码随想录算法训练营第十四天| 递归遍历、迭代遍历
weixin_44041958的博客
03-21 314
思路：左中右，借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。思路：中左右，先记录中间节点，再将右节点和左节点依次压入栈。思路：左右中，反过来就是中右左，那么入栈顺序就是中左右。注意：右节点比左节点先入栈，是为了先让左节点弹出。将要处理的节点放入栈之后，紧接着放入一个。
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 420
代码随想录训练营第十四天 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
Sherry_Sky的博客
11-30 289
代码随想录训练营打卡Day14 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
代码随想录算法训练营第14天 | LeetCode144.二叉树的前序遍历，145.二叉树的后序遍历，94.二叉树的中序遍历 (递归加迭代法，以及统一迭代法)
weixin_46724054的博客
03-14 98
代码随想录算法训练营第14天 | LeetCode144.二叉树的前序遍历，145.二叉树的后序遍历，94.二叉树的中序遍历 (递归加迭代法，以及统一迭代法)
代码随想录算法训练营Day14|二叉树重点理论基础、递归遍历
m0_60979177的博客
12-20 1321
Day14打卡！今日感想：今天开启二叉树篇章！主要学习了递归法的遍历，之前学的有一点“浮于表面”，要注重学习基本逻辑，尽量把问题的根本理解透彻。
代码随想录训练营一刷总结|
weixin_48111139的博客
02-10 1297
自用
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
最新发布
2402_84438596的博客
10-09 1100
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 467
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1329
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 973
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
代码随想录算法训练营第二十二天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值