代码随想录 -- 二叉树(未完待续)

最新推荐文章于 2024-09-10 16:01:56 发布
最新推荐文章于 2024-09-10 16:01:56 发布
阅读量979 收藏 12
点赞数 28
分类专栏： C++ 数据结构与算法 文章标签： c++ linux 开发语言 算法 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bossDDYY/article/details/136580217
版权

文章目录

因为lz考研复试可能优先回溯 动态规划 双指针，所以lz先进行这三样了！！！

二叉树递归遍历

前序遍历题目
后序遍历题目
中序遍历题目

#include<iostream>
#include <vector>

using namespace std;
struct TreeNode{
    int val;
    TreeNode*left;
    TreeNode*right;
    TreeNode():val(0),left(nullptr),right(nullptr){}
    TreeNode(int value):val(value),left(nullptr),right(nullptr){}
    TreeNode(int value,TreeNode*left,TreeNode*right):val(value),left(left),right(right){}
};
class BinaryTree{
public:
    // 先序遍历
    void preorder(TreeNode*root,vector<int>&result){
        if (!root)return;
        result.push_back(root->val);
        preorder(root->left,result);
        preorder(root->right,result);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>result;
        preorder(root,result);
        return result;
    }

    // 后续遍历
    void postorder(TreeNode*root,vector<int>&result){
        if(!root)return;
        postorder(root->left,result);
        postorder(root->right,result);
        result.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int>result;
        postorder(root,result);
        return result;
    }

    //中序遍历
    void in(TreeNode*root,vector<int>&result){
        if(!root)return;
        in(root->left,result);
        result.push_back(root->val);
        in(root->right,result);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>result;
        in(root,result);
        return result;
    }
};
int main(){
    TreeNode*t4 = new TreeNode(7);
    TreeNode*t3 = new TreeNode(8);
    TreeNode*t2 = new TreeNode(3,t3, nullptr);
    TreeNode*t1 = new TreeNode(1);
    TreeNode*t0 = new TreeNode(5,t2,t4);
    TreeNode*root = new TreeNode(10,t0,t1);
    BinaryTree bt;
    // 测试先序遍历
    auto v = bt.preorderTraversal(root);
    for (const auto &item: v) {
        cout<< item <<endl; 
    }
    delete root;
    delete t0;
    delete t1;
    delete t2;
    delete t3;
    delete t4;
    return 0;
}

二叉树迭代遍历

#include<iostream>
#include <vector>
#include<stack>
#include<algorithm>
using namespace std;
struct TreeNode{
    int val;
    TreeNode*left;
    TreeNode*right;
    TreeNode():val(0),left(nullptr),right(nullptr){}
    TreeNode(int value):val(value),left(nullptr),right(nullptr){}
    TreeNode(int value,TreeNode*left,TreeNode*right):val(value),left(left),right(right){}
};
class BinTree{
public:
    // 先序遍历
    /**
    * 栈是先入后出 先序遍历是 中左右
    * 入栈的时候先入右孩子 再入左孩子 这样出栈的时候可以先出左后出右
    * */
    vector<int> preorder(TreeNode*root){
        vector<int>result;//保存遍历之后的结果
        if (root== nullptr)return result;
        stack < TreeNode * > st; // 模拟递归的栈
        st.push(root);
        while (!st.empty()){
            auto r = st.top();
            st.pop();
            result.push_back(r->val);
            if (r->right)st.push(r->right);
            if (r->left)st.push(r->left);
        }
    return result;
    }
    // 后序遍历
    /**
    * 栈是先入后出 后序遍历是 左右中
    * 我们可以按照先序的 不过入栈的时候先入左孩子 再入右孩子
     * 这样的出来的是后序遍历的翻转
     */
    vector<int>postorder(TreeNode*root){
        stack<TreeNode*>st;
        vector<int>result;
        if (root== nullptr)return result;
        st.push(root);
        while (!st.empty()){
            auto r = st.top();
            st.pop();
            result.push_back(r->val);
            if (r->left)st.push(r->left);
            if (r->right)st.push(r->right);
        }
        reverse(result.begin(),result.end());
        return result;
    }

    //中序遍历
    vector<int> inorder(TreeNode*root){
        vector<int>result;
        if (root== nullptr)return result;
        TreeNode*cur = root;
        stack<TreeNode*>st;
        while (cur||!st.empty()){
            if (cur){// 指针来访问节点，访问到最底层
                st.push(cur);// 将访问的节点放进栈
                cur=cur->left;
            }else{
                cur = st.top();// 从栈里弹出的数据，就是要处理的数据
                st.pop();
                result.push_back(cur->val);//中
                cur=cur->right;//右
            }
        }
        return result;
    }
};
int main(){
    TreeNode*t4 = new TreeNode(7);
    TreeNode*t3 = new TreeNode(8);
    TreeNode*t2 = new TreeNode(3,t3, nullptr);
    TreeNode*t1 = new TreeNode(1);
    TreeNode*t0 = new TreeNode(5,t2,t4);
    TreeNode*root = new TreeNode(10,t0,t1);
    BinTree bt;
    auto v = bt.inorder(root);
    for (const auto &item: v) {
        cout<< item <<endl;
    }
    delete root;
    delete t0;
    delete t1;
    delete t2;
    delete t3;
    delete t4;
    return 0;
}

二叉统一的迭代遍历法

代码随想录网站

二叉树的层序遍历合集

二叉树层序遍历I

题目链接

描述

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
在这里插入图片描述

题解

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>result;
        if(root==nullptr)return result;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            vector<int>vec;
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* cur = q.front();
                vec.push_back(cur->val);
                q.pop();
                if (cur->left)q.push(cur->left);
                if (cur->right)q.push(cur->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

二叉树层序遍历II

题目链接

描述

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
在这里插入图片描述

题解

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

二叉树的右视图

题目链接

描述

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

在这里插入图片描述

题解

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

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 len = q.size();
            for (int i = 0; i < len; ++i) {
                auto t = q.front();
                q.pop();
                if(i==len-1)res.push_back(t->val);
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return res;
    }
};

二叉树的层平均值

题目链接

描述

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
在这里插入图片描述

题解

本题就是层序遍历的时候把一层求个总和在取一个均值。

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()){
            const int len = q.size();
            double count=0;
            for (int i = 0; i < len; ++i) {
                auto t = q.front();
                q.pop();
                count+=t->val;
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
            res.push_back(count/len);
        }
        return res;
    }
};

N叉树的层序遍历

题目链接

描述

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
在这里插入图片描述

题解

类似于二叉树的层序遍历

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()){
            vector<int>tmpRes;
            int len = q.size();
            for (int i = 0; i < len; ++i) {
                auto t=q.front();
                q.pop();
                tmpRes.push_back(t->val);
                for (int j = 0; j < t->children.size(); ++j)
                    q.push(t->children[j]);
            }
            res.push_back(tmpRes);
        }
        return res;
    }
};

在每个树行中找最大值

题目链接

描述

您需要在二叉树的每一行中找到最大的值。

在这里插入图片描述

题解

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

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 len = q.size();
            int maxNum=-2147483648;
            for (int i = 0; i < len; ++i) {
                auto t=q.front();
                q.pop();
                maxNum=(t->val>maxNum)?t->val:maxNum;
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
            res.push_back(maxNum);
        }
        return res;
    }
};

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

题目链接

描述

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。
在这里插入图片描述

题解

依旧是层序遍历，不过保存上次层序遍历的节点

class Solution {
public:
    Node* connect(Node* root) {
        if (root== nullptr)return root;
        queue<Node*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            Node*tmp= nullptr;
            for (int i = 0; i < len; ++i) {
                Node*t=q.front();
                q.pop();
                if (tmp)tmp->next=t;
                if (i==len-1)t->next= nullptr;
                else{
                    tmp=t;
                }
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return root;
    }
};

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

题目链接

描述

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

题解

一样的逻辑

class Solution {
public:
    Node* connect(Node* root) {
        if (root== nullptr)return root;
        queue<Node*>q;
        q.push(root);
        while (!q.empty()){
            int len = q.size();
            Node*tmp= nullptr;
            for (int i = 0; i < len; ++i) {
                Node*t=q.front();
                q.pop();
                if (tmp)tmp->next=t;
                if (i==len-1)t->next= nullptr;
                else{
                    tmp=t;
                }
                if (t->left)q.push(t->left);
                if (t->right)q.push(t->right);
            }
        }
        return root;
    }
};

二叉树最大深度

题目链接

描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，
在这里插入图片描述

题解：层序遍历

class Solution {
public:

    int maxDepth(TreeNode*root){
        if (root== nullptr)return 0;
        queue<TreeNode*>q;
        q.push(root);
        int depth=0;
        while (!q.empty()){
            int len = q.size();
            for (int i = 0; i < len; ++i) {
                auto node=q.front();
                q.pop();
                if (node->left)q.push(node->left);
                if (node->right)q.push(node->right);
            }
            ++depth;
        }
        return depth;
    }
};

题解：递归（深度优先搜索）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root)return 0;
        int leftHigh = maxDepth(root->left);
        int rightHigh = maxDepth(root->right);
        return max(leftHigh,rightHigh)+1;
    }
};

二叉树的最小深度

题目链接

描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

题解：层序遍历

只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root== nullptr)return 0;
        queue<TreeNode*>q;
        int depth=0;
        q.push(root);
        while (!q.empty()){
            int len =q.size();
            ++depth;
            for (int i = 0; i < len; ++i) {
                TreeNode*node=q.front();
                q.pop();
                if (!node->left&&!node->right)return depth; 
                if (node->left)q.push(node->left);
                if (node->right)q.push(node->right);
            }
        }
        return depth;
    }   
};

题解：递归（深度优先）

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        if (root->left == nullptr && root->right == nullptr) {
            return 1;
        }

        int min_depth = INT_MAX;
        if (root->left != nullptr) {
            min_depth = min(minDepth(root->left), min_depth);
        }
        if (root->right != nullptr) {
            min_depth = min(minDepth(root->right), min_depth);
        }

        return min_depth + 1;
    }
};

翻转二叉树

题目链接

描述

翻转一棵二叉树。
在这里插入图片描述

题解：递归法

本题使用递归法 很是方便，我们定义一个实现翻转的函数，但root有左/右孩子的时候再翻转其左右孩子，直至root的左右孩子为空

class Solution {
public:
    void invert(TreeNode*root){
        if (root== nullptr)return;
        swap(root->left,root->right);
        invert(root->left);
        invert(root->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        invert(root);
        return root;
    }
};

题解：迭代法

前序遍历和后续遍历途中进行翻转，下面的代码使用的是前序遍历

class Solution {
public:
    TreeNode*invertTree(TreeNode*root){
        if (root== nullptr)return root;
        stack<TreeNode*>st;
        st.push(root);
        while (!st.empty()){
            auto node=st.top();
            st.pop();
            swap(node->left,node->right);
            if (node->right)st.push(node->right);
            if (node->left)st.push(node->left);
        }
        return root;
    }
};

题解：层序遍历

class Solution {
public:
    TreeNode*invertTree(TreeNode*root){
          if (root== nullptr)return root;
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()){
            auto node=q.front();
            q.pop();
            swap(node->left,node->right);
            if (node->left)q.push(node->left);
            if (node->right)q.push(node->right);
        }
        return root;
    }
};

对称二叉树

题目链接

描述

给定一个二叉树，检查它是否是镜像对称的。

在这里插入图片描述

题解：递归

class Solution {
public:
    bool compare(TreeNode*left,TreeNode*right){
        if (left&&!right)return false;
        else if(!left&&right)return false;
        else if (!left&&!right)return true;
        else if(left->val!=right->val)return false;

        bool leftFlag = compare(left->left,right->right);
        bool rightFlag = compare(left->right,right->left);

        return leftFlag&&rightFlag;
    }
    bool isSymmetric(TreeNode* root) {
        if (!root)return true;
        return compare(root->left,root->right);
    }
};

题解：迭代法

class Solution {
public:
    bool isSymmetric(TreeNode*root) {
        if (!root)return true;
        queue<TreeNode*>q;
        q.push(root->left);
        q.push(root->right);
        while (!q.empty()){
            auto n1=q.front();q.pop();
            auto n2=q.front();q.pop();
            if (!n1&&!n2)continue;
            if (n1&&!n2||!n1&&n2||n1->val!=n2->val)return false;
            q.push(n1->left);
            q.push(n2->right);
            q.push(n1->right);
            q.push(n2->left);
        }
        return true;
    }
};
yb0os1
关注
专栏目录
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 579
代码随想录-035期-算法训练营【博客笔记汇总表】
leetcode刷题笔记8-二叉树（未完待续）
infinite2020的博客
04-03 149
因为我们在刷leetcode的时候，刷题模式是核心代码模式，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;//存储对应节点的数值 TreeNode * left;//定义左指针，指向左孩子 TreeNode * right;
代码随想录总结 | 慢慢总结,想起啥就先写上
he979731102的博客
02-23 391
算法总结
Leetcode刷题注意点：二叉树
Ajdidfj的博客
01-29 311
基于代码随想录的Leetcode刷题注意点
代码随想录总结
he979731102的博客
03-15 374
算法和数据结构总结
代码随想录算法训练营第十五天 | 二叉树 part 2 | 层序遍历、反转二叉树、对称二叉树
enzoherewj的博客
08-23 104
这道题不是简单比较左孩子和右孩子，而是比较左树内侧外侧，和右树内侧外侧。今天其他的10题基本上可以用类似的写法写完。有几道题的卡了一会所以记录一下。未完待续：还有很多种其他的写法，比如说用队列和栈来实现，等有空了再补上去。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。具体的细节和前序遍历，后序遍历的时候差不多，只是多加了一句交换的代码。最小深度就是相当于BFS遍历到的第一个满足。层序遍历使用队列的结构。
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
数据结构第五章-树与二叉树 二叉树的C语言实现代码
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
【c++23种设计模式概述】
m0_45463480的博客
09-09 814
c++23种设计模式概述。
C语言作用域
天道酬勤
09-07 1029
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
＜C++＞ set、map模拟实现
最新发布
prodigy623的博客
09-10 838
set、map仿STL模拟实现
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 712
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 1036
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 300
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
STL经典案例（四）——实验室预约综合管理系统（项目涉及知识点很全面，内容有点多，耐心看完会有收获的！）
beyond谚语的博客
09-08 441
高校实验室预约管理系统 管理员：创建实验室教师账号、学生账号、实验室；查看实验室教师、学校、实验室信息；清空所有学生的预约记录 学生：申请实验室预约、查看所有实验室预约 实验室教师：审核学生的申请、查看所有学生的实验室申请预约
C 语言实例：掌握基础与进阶技巧
wjs2024的博客
09-10 326
C 语言作为一门古老而强大的编程语言，自诞生以来就广受欢迎。它以其高效率、灵活性和功能强大著称，是许多现代编程语言的基础。本文旨在通过一系列实例，帮助读者深入理解 C 语言的基础知识和进阶技巧。
7-1 完全二叉树的层序遍历
04-22
完全二叉树是一种特殊的二叉树，它的每一层都是从左到右依次填满的，除了最后一层可能不满。层序遍历是一种按照树的层级顺序遍历节点的方法。 对于完全二叉树的层序遍历，可以使用队列来实现。具体步骤如下： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值