代码随想录第13天|二叉树操作

已于 2024-05-23 16:48:00 修改
阅读量517 收藏 7
点赞数 6
文章标签： 算法
于 2024-05-22 19:32:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45910863/article/details/139115725
版权

层序遍历

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

通过递归实现
递归的三要素

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

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

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

1.参数：指针，结果数组，当前层数
2.终止条件：当前指针为空就返回，如果指针来到一个新层，就给结果数组里添加一个空数组
3.单层逻辑：遍历到一个新节点就放入该层的数组中，之后再考虑遍历其左右孩子，其实递归的访问顺序没有满足层序遍历（满足前序遍历），因为一直在访问左孩子，但是res[depth].push_back(cur->val)确保了访问的节点填入到对应的层的数组中的正确位置

/**
 * 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 lorder(TreeNode* cur,vector<vector<int>>& res,int depth){
        if(cur == nullptr) return;
        // 遍历到当前新层时，需要 新添加一个数组
        if(res.size() == depth) res.push_back(vector<int>());
        res[depth].push_back(cur->val);
        lorder(cur->left,res,depth+1);
        lorder(cur->right,res,depth+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root ==nullptr) return res;
        lorder(root,res,0);
        return res;
    }
};

199.二叉树的右视图

在这里插入图片描述
使用层序遍历，记录每一层的最后一个节点即可(cur)

/**
 * 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 size = q.size();
            TreeNode* cur;
            for(int i = 0; i < size; i++){
                cur = q.front();
                q.pop();
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
            // cur最后指向的是本层最后一个元素
            res.push_back(cur->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;
        if(root == nullptr) return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            double sum = 0;
            int size = q.size();
            for(int i = 0; i < size; i++){
                TreeNode* cur = q.front();
                q.pop();
                sum += cur->val;
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
            res.push_back(sum / size);
        }
        return res; 
    }
};

429.N叉树的层序遍历

在这里插入图片描述
同理，只是把左右孩子节点的遍历更换成了遍历vector数组，同时需要判定某个孩子是否为null

/*
// 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 == NULL) return res;
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int size = q.size();
            vector<int> r;
            for(int i = 0; i < size; i++){
                Node* cur = q.front();
                q.pop();
                r.push_back(cur->val);
                for(int j = 0; j < cur->children.size(); j++){
                    if(cur->children[j] != NULL) q.push(cur->children[j]);
                }
            }
            res.push_back(r);
        }
        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 size = q.size();
            int maxn = INT_MIN;
            for(int i =0; i<size;i++){
                TreeNode* cur = q.front();
                maxn = max(maxn,cur->val);
                q.pop();
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
            res.push_back(maxn);
        } 
        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) {
        Node* cur;
        if(root == NULL) return root;
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int size = q.size();
            vector<Node*> r;
            for(int i = 0; i <size; i++){
                cur = q.front();
                q.pop();
                r.push_back(cur);
                if(cur->left!=NULL) q.push(cur->left);
                if(cur->right!=NULL) q.push(cur->right);
            }
            r.push_back(NULL);
            for(int i = 0; i < size; i++){
                r[i]->next = r[i+1];
            }
        }
        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) {
        int depth = 0;
        if(root == nullptr) return 0;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int size = q.size();
            depth++;
            for(int i = 0; i < size;i++){
                TreeNode* cur = q.front();
                q.pop();
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
        }
        return depth;
    }
};

DFS解法

/**
 * 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:
    // 1.参数只需要指针
    int maxDepth(TreeNode* root) {
        // 2.判断递归终止条件
        if(root == nullptr) return 0;
        // 3.确定递归逻辑，使用后续遍历访问顺序，获取左子树和右子树中的深度，取最大值
        int left = maxDepth(root->left);
        int right = maxDepth(root->right);
        return max(left,right) + 1;
    }
};

111.二叉树最小深度

在这里插入图片描述
记录当前深度，如果碰见某个节点左右孩子都为空，则表示其为叶节点，说明该层就是最小深度。
如果题目改为N叉树，那么则是判断其是否为叶节点（无孩子）即可。

/**
 * 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;
        queue<TreeNode*> q;
        q.push(root);
        int depth = 0;
        while(!q.empty()){
            int size = q.size();
            depth++;
            for(int i = 0; i < size;i++){
                TreeNode* cur = q.front();
                q.pop();
                if(cur->left==nullptr && cur->right==nullptr) return depth;
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
            }
        }
        return depth;
    }
};

翻转二叉树

在这里插入图片描述

使用后序遍历(前序遍历也可)

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr) return nullptr;
        TreeNode* left = invertTree(root->left);
        TreeNode* right = invertTree(root->right);
        root->left = right;
        root->right = left;
        return root;
    }
};

前序遍历（迭代）

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr)
            return root;
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode* cur = st.top();
            st.pop();
            if (cur != NULL) {
                if (cur->right)
                    st.push(cur->right);
                if (cur->left)
                    st.push(cur->left);
                st.push(cur);
                st.push(NULL);
            } else {
                TreeNode* t = st.top();
                st.pop();
                swap(t->left, t->right);
            }
        }
        return root;
    }
};

对称二叉树

在这里插入图片描述
个人想法：用层序遍历来检查：除了第一层的其他层里，节点个数是否为偶数且对称

/**
 * 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:
    bool check(vector<TreeNode*> r) {
        int mid = r.size() / 2;
        for (int i = mid - 1, j = mid; i >= 0 && j < r.size(); i--, j++) {
            if (r[i] == NULL && r[j] == NULL)
                continue;
            if (r[i] != NULL && r[j] != NULL && r[i]->val == r[j]->val)
                continue;
            else
                return false;
        }
        return true;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL)
            return false;
        queue<TreeNode*> q;
        q.push(root);
        TreeNode* cur;
        while (!q.empty()) {
            int size = q.size();
            if (size % 2 != 0 && q.front() != root)
                return false;
            vector<TreeNode*> r;
            for (int i = 0; i < size; i++) {
                cur = q.front();
                q.pop();
                r.push_back(cur);
                // 这里注意，这种操作保证了将NULL放入队列，且遍历到NULL的时候不会继续入队列
                if(cur != NULL){
                    q.push(cur->left);
                    q.push(cur->right);
                }
                
            }
            if (cur == root)
                continue;
            if (!check(r))
                return false;
        }
        return true;
    }
};

递归写法：
使用后序遍历

/**
 * 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:
    bool Symmetric(TreeNode* left,TreeNode* right){
        // 使用后序遍历，从最底层向高层开始判断是否对称
        if(left != nullptr && right == nullptr) return false;
        else if(left == nullptr && right!=nullptr) return false;
        else if(left == nullptr && right==nullptr) return true;
        else if(left->val != right->val) return false;
        // 如果left和right相等不能直接return true，因为要进入下一层判断
        bool outside = Symmetric(left->left,right->right);
        bool inside = Symmetric(left->right,right->left);
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;
        return Symmetric(root->left,root->right);
    }
};

迭代法：
把队列改成栈也行
在这里插入图片描述

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr)
            return true;
        queue<TreeNode*> q;
        q.push(root->left);
        q.push(root->right);
        while (!q.empty()) {
            TreeNode* left = q.front();
            q.pop();
            TreeNode* right = q.front();
            q.pop();
            if (left == nullptr && right == nullptr)
                continue;
            else if (left != nullptr && right == nullptr)
                return false;
            else if (left == nullptr && right != nullptr)
                return false;
            else if (left->val != right->val)
                return false;
            q.push(left->left);
            q.push(right->right);
            q.push(left->right);
            q.push(right->left);
        }
        return true;
    }
};
Tekie1
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录第13天|二叉树递归遍历，迭代遍历
2301_79476584的博客
01-26 214
递归思路刚开始学习时还需要仔细想想怎么进入的。
代码随想录第十一天|二叉树的遍历
semirc9的博客
07-08 1140
二叉树的遍历
代码随想录第13天 | 二叉树 递归遍历 迭代遍历 统一迭代 层序遍历
qdy1014的博客
07-07 122
【代码】代码随想录第13天 | 二叉树 递归遍历 迭代遍历 统一迭代 层序遍历。
代码随想录第十二天|二叉树
m0_74934708的博客
03-05 1479
该方法将前、中、后序遍历的方法统一起来，核心思想在于将父结点入栈后出栈再入栈，第二次入栈时再入栈空结点进行标记，这样第二次出栈时可以此为标志进行出栈操作。后序遍历：与前序遍历类似，改变左右子结点入栈的顺序，最后将存储子结点值的数组进行反转即可。3、遍历方式：深度优先（前序遍历、中序遍历、后序遍历）、广度优先（层次遍历）1、种类：满二叉树、完全二叉树、二叉搜索树、平衡二叉搜索树。2、存储方式：链式存储（左右结点指针和结点值）、顺序存储。1、确定递归函数的参数和返回值。3、确定单层递归的逻辑。
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
「代码随想录」二叉树专题精讲（v1.2）.pdf
12-14
"代码随想录二叉树专题精讲" 本资源是关于二叉树的专题讲解，涵盖了二叉树的基本概念、avl树、红黑树、堆、trie树等多种二叉树结构的实现和应用。 知识点一：二叉树的基本概念 二叉树是一种特殊的树状结构，它的每...
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 878
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 339
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 605
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 143
【代码】代码随想录算法训练营第33天。
《算法笔记》总结No.4——散列
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-07 739
散列的英文名是hash，即我们常说的哈希~该知识点在王道408考研的教材里面属于的范围。即便各位并无深入了解过，也听说过散列是一种更高效的查找方法。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 468
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
Leetcode104.求二叉树的最大深度
知道这个有什么用？
07-10 289
【代码】Leetcode104.求二叉树的最大深度。
【代码随想录】【算法训练营】【第62天】 [卡码108]冗余连接 [卡码109]冗余连接II
weixin_54954007的博客
07-08 585
思路及算法思维，指路。题目来自。day 62，又是一个周一，ding~
GANs算法简介、学习步骤及具体实现
weixin_41850878的博客
07-08 1237
生成对抗网络（Generative Adversarial Networks，GANs）自从2014年由Ian Goodfellow等人提出以来，已经成为深度学习领域中最活跃的研究方向之一。GAN的基本思想是利用两个神经网络——生成器（Generator）和判别器（Discriminator）——之间的对抗训练，生成器尝试生成逼真的样本以欺骗判别器，而判别器则试图区分生成的样本和真实的样本。随着时间的推移，两个网络相互竞争，最终生成器学会生成高质量的样本。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值