day07二叉树

已于 2023-09-12 22:36:28 修改
阅读量48 收藏
点赞数
文章标签： 哈希算法 算法 leetcode
于 2023-09-11 11:25:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bian100816/article/details/132715764
版权

二叉树

map set multimap multiset的底层实现是：平衡二叉搜索树
unordered_map unordered_set 的底层实现是哈希表

二叉树的递归遍历

每次写递归，都按照这三要素来写

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

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

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

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> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
    void traversal(TreeNode* cur,vector<int>& vec){
        if(cur == nullptr) return;
        vec.push_back(cur->val);
        traversal(cur->left,vec);
        traversal(cur->right,vec);
    }
};

非递归法：迭代法

/**
 * 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> result;
        stack<TreeNode*> st;
        if(root==nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top(); // 中
            st.pop();
            result.push_back(node->val);
            if(node->right) st.push(node->right);// 右（空节点不入栈）
            if(node->left) st.push(node->left); // 左（空节点不入栈）
        }

        return result;
    }
};

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> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
     void traversal(TreeNode* cur,vector<int>& vec){
        if(cur == nullptr) return;
        
        traversal(cur->left,vec);
        vec.push_back(cur->val);
        traversal(cur->right,vec);
    }
};

非递归法：迭代法

/**
 * 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> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur != nullptr || !st.empty()){
            if(cur != nullptr){// 指针来访问节点，访问到最底层
                st.push(cur);// 指针来访问节点，访问到最底层
                cur=cur->left;
            }else{
                cur = st.top();
                st.pop();
                result.push_back(cur->val);// 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                cur=cur->right;
            }
        }
        return result;
    } 
};

145.二叉树的后序遍历

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

非递归法：迭代法

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root==nullptr) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top(); // 中
            st.pop();
            result.push_back(node->val);
            
            if(node->left) st.push(node->left); // 左（空节点不入栈）// 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if(node->right) st.push(node->right);// 右（空节点不入栈）
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了  
        return result;
    }
};

前中序的的统一的迭代法
略

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*> que;
        if(root!=nullptr) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

/**
 * 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 order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());//往二维数组里插入空的vector<int>()
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

107.二叉树的层次遍历 II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end());// 在这里反转一下数组即可
        return result;
    }
};

199.二叉树的右视图

vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        //vector<vector<int>> result;
        vector<int> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec[vec.size()-1]);
        }
        return result;
    }

vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val); // 将每一层的最后元素放入result数组中
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }

637.二叉树的层平均值

vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        vector<double> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            double sum = 0;// 统计每一层的和
            for(int i=0; i<size; i++){
                TreeNode* node = que.front();
                que.pop();
             ///   vec.push_back(node->val);
                sum+=node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            /// for(double s:vec)
            ///     sum+=s;
            /// sum/=vec.size();
            /// result.push_back(sum);
            result.push_back(sum/size);
        }
        return result;
    }

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) {
        queue<Node*> que;
        if(root!=nullptr) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            double sum = 0;// 统计每一层的和
            for(int i=0; i<size; i++){
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i=0; i<node->children.size(); i++){// 将节点孩子加入队列
                    if(node->children[i]) que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

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

层序遍历，取每一层的最大值

vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;
            int maxValue=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                //vec.push_back(node->val);
                maxValue=maxValue>node->val?maxValue:node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(maxValue);
        }
        return result;
    }

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

还有一点问题 我觉得 1–》2 但是1应该指向null

Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty()){
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            //vector<int> vec;
            Node* nodePre;
            Node* node;
            for(int i=0;i<size;i++){
                if(i == 0){
                    nodePre = que.front();//取出一层的头结点
                    que.pop();
                    node = nodePre;
                }
                else{
                    node = que.front();
                    que.pop();
                    nodePre->next=node;// 本层前一个节点next指向本节点
                    nodePre=nodePre->next;
                }
                // Node* node = que.front();
                // que.pop();
                // vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            nodePre->next=NULL;// 本层最后一个节点指向NULL
        }
        return root;
    }

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

同上

104.二叉树的最大深度

int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        
        int depth = 0;
        while(!que.empty()){
            depth++;//记录深度
            int size =que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return depth;
    }

111.二叉树的最小深度

int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if(!node->left && !node->right) // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                return depth;
            }
        }
        return depth;
    }
遗失的美好886
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
Day21 二叉树part07
qq_44763553的博客
02-03 368
思路：双指针一个cur记录当前结点，一个pre记录之前结点。二叉搜索树一定是中序遍历，只有中序遍历元素可以保持有序。代码技巧：判断count和max_count的大小。要在最大计数更新之后开始把result置空。
Day 6 二叉树
你们的伟仔的博客
12-17 187
二叉树的(层序)遍历相当于广度优先遍历，(前序)遍历相当于深度优先遍历。
Day15 二叉树
SuperSwaggy的博客
03-20 450
感想：二叉树之前没怎么做过，给我感觉挺灵活的，有时候没想到可以这样子做，而且很多数据结构也用到了二叉树，比如堆，周末我想总结一下java各个常用的数据结构的方法的时间复杂度。思路：层序遍历就是从层的两侧向中间去遍历，如果两侧的值不一样或者有空的值就肯定不是对称的。思路：我这样写也可以做出来，最方便的办法肯定就是正向的层序遍历之后把答案翻转，还有一种不用翻转用LinkedList这个链表添加到头就行了。思路：其实这题就是层序遍历的最后一个值的集合，所以只要把每一层的最后一个节点写进结果数组中就可以。
day13 二叉树
weixin_45843534的博客
07-03 86
这次代码学习的小目标是学完二叉树，，没想到进度如此之快。
Day14 二叉树
jetgu0000的博客
05-26 238
此处，我们希望stack为空时停止，但是不希望第一次就停止。同时，自己写的时候容易犯一个问题，对于从栈中弹出的元素重新获取左侧元素，这会导致重复与死循环。以上两种写法都可以写成闭包的。***看起来简单，实际上写起来容易漏洞百出***使用栈来实现想要的过程。# 二叉树的非递归遍历。# 二叉树的递归遍历。# 二叉树的统一迭代。标记法，了解思路即可。
day12二叉树
xiaoshuo6688的博客
01-10 477
day 13 二叉树
xiaoshuo6688的博客
01-12 422
day17 构造二叉树
sk142536的博客
06-18 251
leetcode 105 从前序与中序遍历序列构造二叉树 这道题感觉好难，但是通过这道题也学到了好多东西 构成二叉树 中序序列和前、后，层次序列任一组合唯一确定一颗二叉树。前、后，层次序列都是提供根结点的信息，中序序列用来区分左右子树；没有中序遍历是无法构成一棵二叉树的 前序、中序、后续遍历还原二叉树 关于这部分，这个大佬写的很棒 还原二叉树 一、前序+中序 根据前序序列的第一个元素建立根结点； 在中序序列中找到该元素，确定根结点的左右子树的中序序列； 在前序序列中确定左右子树的前序序列； 由左子树的前
day 15 二叉树02
m0_58680381的博客
04-05 205
用deque来模拟队列，从这道题通过代码调试我真正清楚了二叉树具体的数据结构，比如root是一大坨、所有的数据，root.left，root.right是左右子树，root.val，是根节点的数值。result存放总的结果，level存放每一层的结果。用popleft来弹出队列口的元素。需要考虑的情况：左空右不空，左不空右空，左右都空，左右都不空：比较值是否相等。用后序，什么情况需要后序遍历：需要收集孩子节点信息并且要返回给上一层的时候。我是第一遍学习二叉树，所以目前我就只学了递归法，迭代法我先放置了。
Day 2 二叉树剪枝
咸鱼…
07-22 315
Leetcode刷题day2: 814. 二叉树剪枝
春节7天练丨Day5：二叉树和堆1
08-03
关于二叉树和堆的 7 个必知必会的代码实现二叉树实现一个二叉查找树，并且支持插入、删除、查找操作实现查找二叉查找树中某个节点的后继、前驱节点实现二叉树前、中、后
2-1_二叉树、查找排序算法_Day02_AM.mp4
04-01
2-1_二叉树、查找排序算法_Day02_AM.mp4
LeetCode90Day挑战
02-10
《LeetCode90Day挑战——Java解题指南》 LeetCode90Day挑战是一场针对编程爱好者和专业开发者的自我提升活动，旨在通过90天的持续练习，提高编程技能，特别是解决算法问题的能力。在这个挑战中，参与者将面对...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 882
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 349
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
代码随想录算法训练营第33天
m0_62262158的博客
07-10 148
【代码】代码随想录算法训练营第33天。
【算法】平衡二叉树
最新发布
时清云的博客
07-13 153
难度：简单。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值