LeetCode——二叉树

最新推荐文章于 2023-12-09 22:21:43 发布
最新推荐文章于 2023-12-09 22:21:43 发布
阅读量817 收藏
点赞数
文章标签： 二叉树 数据结构 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arashi_5/article/details/114777458
版权

二叉树

二叉树概念和性质

参考博客

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)
          return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

98. 验证二叉搜索树（中序遍历）

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。
    在这里插入图片描述
    解法一 用一个数组存放经过中序遍历的结点值
  • 由于要求所有的左子树小于当前结点所有右子树大于当前结点，因此可以利用中序遍历，将二叉树线性化，得到一个序列，后面只需判断这个序列是否严格升序就好了（不能有相同元素）
  • 时间空间都是O(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:
    bool isValidBST(TreeNode* root) {
    	//中序遍历得到的序列
        vector<int>treeNum;
        //对二叉树进行中序遍历
        InOrderTraverse(root,treeNum);
        //判断是否升序
        for(int i=1;i<treeNum.size();i++)
        {
            if(treeNum[i]<=treeNum[i-1])
                return false;
        }
        return true;
    }
    //中序遍历（左根右）
    void InOrderTraverse(TreeNode * root,vector<int>&arr)
    {
        if(root)
        {
        	//递归调用
            InOrderTraverse(root->left,arr);
            arr.push_back(root->val);
            InOrderTraverse(root->right,arr);
        }
    }
};

解法二 在中序遍历过程中直接判断是否有序（来自题解【代码随想录】）

  • 不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。
  • 要定义一个long long的全局变量，用来比较遍历的节点是否有序，因为后台测试数据中有int最小值，所以定义为long long的类型，初始化为long long最小值。
  • 终止条件：节点为空时，返回true
  • 单层递归逻辑：中序遍历，一直更新maxVal，一旦发现maxVal >= root->val，就返回false，注意元素相同时候也要返回false。

代码

class Solution {
public:
    long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;

        bool left = isValidBST(root->left);
        // 中序遍历，验证遍历的元素是不是从小到大
        if (maxVal < root->val) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);

        return left && right;
    }
};

101. 对称二叉树（代码比较精巧，不好理解）

给定一个二叉树，检查它是否是镜像对称的。
在这里插入图片描述
注意：

上图中下面的那个示例，说明即使数字是对称的，但是所在的位置不是镜像对称的也不是对称二叉树，所以不能只考虑比较结点值，而应注意是否为对称位，因此不能验证通过中序遍历得到的数组是否是回文串来判断是否为对称二叉树。

思路： （官方题解）

  • 利用一个递归函数check，通过同步移动两个指针的方法来遍历这棵树
  • p指针和q指针一开始都指向根节点，随后p往左子树跳时，q往右子树跳；p往右子树跳时，q往左子树跳。
  • 每次跳都检查当前p和q的结点值是否相等，以及是否对称（当有一个为空而另外一个不为空时说明不对称）。

代码

class Solution {
public:
    bool check(TreeNode *p, TreeNode *q) {
    	//都为空时返回true
        if (!p && !q) return true;
        //只有一个为空时，说明不对称，返回false
        if (!p || !q) return false;
        //比较当前结点值，以及利用递归遍历整棵树
        return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

102. 二叉树的层序遍历（中等，参考题解，自己码的代码）

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

  • 由于需要逐层遍历结点，所以想到要用广度优先遍历，利用队列实现（之前学数据结构的时候学到的，还好还记得）
  • 但是本题不能用普通的广度优先遍历得到一个一维数组，而是要得到一个根据层序排列的二维数组，这里我参考了官方题解的做法，就是：
    • 首先根元素入队
    • 当队列不为空的时候
    1. 求当前队列的长度 size
    2. 依次从队列中取 size个元素进行拓展（将结点的左子树和右子树压到队尾，如果有的话），然后进入下一层的迭代
  • 也就是说，每次进行拓展的size个元素是属于同一层的，将这些数用一维数组存起来，每层拓展完成后将这个数组加到二维数组中去。

代码

/**
 * 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) {
       if(!root) return{};
       vector<vector<int>>result;
       vector<int>tmp;

       TreeNode* node;
       //利用队列
       queue<TreeNode*>que;
       //放入根结点
       que.push(root);
       while(!que.empty())
       {
           //求出每层的节点数
           int queSize=que.size();
           //展开que中queSize个元素（属于同一层的元素）
           for(int i=0;i<queSize;i++)
           {
             //取出队列中的第一个元素
             node=que.front();
             //然后将它弹出
             que.pop();
             //将节点值插入数组
             tmp.push_back(node->val);
             
             //展开当前节点的坐左子树和右子树（如果有的话）
             //将左孩子和右孩子节点压到队列尾部
             if(node->left)
             que.push(node->left);

             if(node->right)
             que.push(node->right);
            }
        //向结果数组压入二叉树每层的节点值
        result.push_back(tmp);
        tmp.clear();
       }
       return result;
    }
};

108. 将有序数组转换为二叉搜索树（递归）

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
在这里插入图片描述
思路：

  • 主要原理是将一个中序数组构造成搜索二叉树，且满足高度平衡。
  • 利用一个递归函数实现，每次递归都将数组中间位置的值作为根节点（如果数组长为偶数，那就取中间靠左的那个）。
  • 新的根节点需要创建在堆区，否则不能返回它的地址。
  • 左半段数组同样是一个中序数组，继续递归，作为左子树，右半段数组同。
  • 关键是如何截取数组

代码

/**
 * 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* sortedArrayToBST(vector<int>& nums)
    {
        //借助一个递归函数来实现
        return helper(nums,0,nums.size()-1);
    }
    TreeNode * helper(vector<int>& nums,int left,int right)
    {
    	//终止条件
        if(left>right)
        return nullptr;
        //中序序列构造搜索二叉树
        //每次取数组中点作为根节点
        int mid=(left+right)/2;
        //递归调用，创建一个新节点，左子树为数组左半段，右子树为数组右半段
        TreeNode* root=new TreeNode(nums[mid],helper(nums,left,mid-1),helper(nums,mid+1,right));
        //返回根节点地址（开辟在堆区）
        return root;
    }
};

剑指 Offer 04. 二维数组中的查找（二叉搜索树）

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
在这里插入图片描述
思路：

  • 矩阵matrix有非常特殊的排列方式，从上到下递增，从左到右递增。
  • 那么对于最左下和最右上的元素，可将其分别作为根节点，将矩阵看做一个二叉搜索树，15左边的元素更小，右边元素更大；18上边元素更小，右边元素更大。
    在这里插入图片描述
  • 将矩阵上建立直角坐标系，假如从18那个位置（坐标原点）开始搜索，假如小于目标target=5，则将搜索位置向右移动，大于则向上移动
    在这里插入图片描述
    代码
bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
		//注意异常判断
        if(matrix.empty())
        return 0;
        int m=matrix.size(),n=matrix[0].size();
        //从最左下开始搜索
        int i=m-1,j=0;
        while(i>=0&&j<n)
        {
            if(target<matrix[i][j])
            i--; //向上
            else if(target>matrix[i][j])
            j++; //向右
            else
            return true;
        }
        return false;
    }

剑指 Offer 07. 重建二叉树（递归，二叉树遍历）

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
示例一

思路

  • 先序遍历的第一个结点为根，在中序遍历中确定根节点的位置
  • 根据中序遍历的特点，中序根节点前的为左子树，后边的为右子树
  • 由此可以得到先序遍历中的左子树和右子树，然后递归，再从左右子树中确定根节点以及他们的左右子树
    思路
  • 注意：递归实现中，不要忘了终止条件！！！
  • 左右子树的边界要仔细想想

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //递归构建，后面四个参数分别为前序和中序遍历的左右界
    TreeNode* mybuild(vector<int>& preorder, vector<int>& inorder,unordered_map<int,int>& index,int pre_left,int pre_right,int in_left,int in_right)
    {
        //不要忘了递归终止条件！！！
        if(pre_left>pre_right)
        return NULL;

        //先序遍历中的根节点
        int pre_root=preorder[pre_left];

        //构建根节点
        TreeNode* root=new TreeNode(pre_root);

        //根据先序根节点找中序遍历根节点
        int in_root=index[pre_root];
        //根据中序根节点计算左子树长度
        int left_size=in_root-in_left;

        //构建左子树，最后四个参数分别为先序和中序遍历中的左子树部分
        root->left=mybuild(preorder,inorder,index,pre_left+1,pre_left+left_size,in_left,in_root-1);

        //构建右子树，后四个参数分别为先序和中序遍历中的右子树部分
        root->right=mybuild(preorder,inorder,index,pre_left+left_size+1,pre_right,in_root+1,in_right);

        return root;

    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n=preorder.size();
        unordered_map<int,int>index;
        for(int i=0;i<inorder.size();i++)
        {
            index[inorder[i]]=i;
        }

        TreeNode* head=mybuild(preorder,inorder,index,0,n-1,0,n-1);

        return head;
    }
};

617. 合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

思路：

  • 递归，深度优先
  • 如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，用一个新节点作为合并后的节点，而不是修改原来的节点值
  • 如果有一个为空，则将另外一个不为空的节点作为新二叉树的节点
  • 如果两个节点都为空，就返回空NULL

代码

/**
 * 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* mergeTrees(TreeNode* root1, TreeNode* root2) {
        //如果两节点均非空
        if(root1!=NULL&&root2!=NULL)
        {
            int m_val=root1->val+root2->val;
            //构造一个新节点，值为重复节点的值的和
            TreeNode* newRoot=new TreeNode(m_val);
            //递归构造左右子树
            newRoot->left=mergeTrees(root1->left,root2->left);
            newRoot->right=mergeTrees(root1->right,root2->right);
            return newRoot;
        }
        //有一个为空
        else if(root1==NULL)
        {
            return root2;
        }
        else if(root2==NULL)
        {
            return root1;
        }
        //都为空
        return NULL;
    }
};

复杂度

  • 时间O(min(m,n))，m和n分别是两个二叉树的节点数。对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应节点都不为空时才会对该节点进行显性合并操作，因此被访问到的节点数不会超过较小的二叉树的节点数。
  • 空间O(min(m,n))。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。

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

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点（完全二叉树）。
填充它的每个next指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next指针设置为 NULL。
初始状态下，所有 next 指针都被设置为NULL

进阶：
你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
在这里插入图片描述
解法一

  • 层次遍历，用辅助队列，空间O(N)
  • 层次遍历基于广度优先搜索，它与广度优先搜索的不同之处在于，广度优先搜索每次只会取出一个节点来拓展，而层次遍历会每次将队列中的所有元素都拿出来拓展，这样能保证每次从队列中拿出来遍历的元素都是属于同一层的
  • 注意进行异常输入判断，检查输入是否为空指针
class Solution {
public:
    Node* connect(Node* root) {
        //广度优先搜索，层次遍历
        queue<Node*>Q;
        int n=0;
        if(root==NULL)
        return root;
        Q.push(root);
        while(!Q.empty())
        {
            int size=Q.size();
            for(int i=0;i<size;i++)
            {
                Node* tmp=Q.front();
                Q.pop();
                if(i!=size-1)
                tmp->next=Q.front();
                if(tmp->left!=NULL)
                Q.push(tmp->left);
                if(tmp->right!=NULL)
                Q.push(tmp->right);
            }
            n++;
        }
        return root;
    }
};

解法二

  • 使用已建立的next 指针，迭代，思路见官方题解
  • 空间O(1)

解法三

  • 思路同解法二，只是用的递归实现
    在这里插入图片描述
ninomiya33
关注
LeetCode——二叉树序列化与反序列化
Jormungand_V的博客
07-17 501
文章目录题目思路问题一问题二代码实现 题目 请实现两个函数，分别用来序列化和反序列化二叉树。 设计一个算法来实现二叉树的序列化与反序列化。不限定序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 以上图为例： 输入： root = [1,2,3,null,null,4,5] 输出：[1,2,3,null,null,4,5] 思路 两个问题： 序列化是以怎样的顺序？ 反序列化是如何进行的？ 其实这两个问题也就是让人刚读完题感到无
爆刷leetcode——二叉树（二）——路径问题（一）
m0_64240499的博客
09-13 174
枚举每一条从根节点到叶子节点的路径，当遍历到叶子节点时，我们判断此时的路径和是否等于目标值，如果等于就将这个路径加入结果。递归结束需要回溯到上一个节点，判断父节点的另外一个孩子的路径是否满足条件。访问每一个节点root，检测从root节点从上到下中有多少条满足条件的路径。从某一个节点开始（不一定是根节点），从上到下开始寻找路径，直到某一个节点（不一定是叶子节点）结束，这个问题与第二个问题相比，从任意节点到另一任意节点的路径，不需要自定向下，该路径是可以。题目已经明确规定该路径必须是。
计算给定二叉树叶子节点的数目
03-04
实验报告 采用链式存储结构求任意给出的二叉树的叶子节点个数，过程有详解，包括过程中的错误。
二叉树——求叶子结点树
cyn227的博客
05-03 763
【代码】二叉树——求叶子结点树。
代码实现求二叉树结点数和叶子结点数（C语言）
Prefectkn的博客
07-20 8709
本篇博客讲解递归方法求二叉树叶子结点数，和结点总数。使用C语言从理论落实到代码。
「leetcode」222.完全二叉树的节点个数
代码随想录
10-08 256
完全二叉树的节点个数
C语言二叉树求叶子数
只为成功找方法 不为失败找借口
06-06 3798
二叉树的终端节点也称二叉树的叶子，求二叉树的叶子数可以采用任何遍历算法，下面是求二叉树叶子数的一个例子： #include #include typedef struct binode{ char data; struct binode *lchild, *rchild; }bitnode, *bitree; bitree createbitree() { bitree t; c
2022.2.28 LeetCode —— 二叉树
LGoGoGo的博客
02-28 551
找左下角的值
2022.3.14 LeetCode —— 二叉树
LGoGoGo的博客
03-14 295
二叉搜索子树的最大键值和 —— 后序遍历
Leetcode——二叉树的最大深高度/最小深度/直径
Yawn
07-08 590
1. 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 2. 题解 解法一： 递归 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(i
二叉树的节点个数
11-13
设有一棵二叉树，其节点值为字符型并假设各值互不相等，采用二叉链表存储表示。现输入其扩展二叉树的前序遍历序列，要求建立该二叉树，并求其节点个数。
用C语言求二叉树叶子结点
04-18
数据结构实验 求二叉树叶子结点 C语言描述 源代码直接运行
二叉树的结点个数、叶子结点个数的代码实现＜分治算法＞
最新发布
m0_73975164的博客
12-09 1105
分治算法是一种将问题划分为更小的子问题，并通过解决子问题来解决原始问题的算法设计策略，​由于子问题与原问题在结构和解法上的相似性，用分治方法解决的问题，大都采用了递归的形式
【二叉树代码】考试常考的代码题（求叶子数、非叶子数、度为1、度为2、深度…）
CS GO
08-17 582
二叉树一些常考的简单代码题合集
Java创建遍历二叉树（递归）并求树高及叶节点个数（代码全）
m0_55975991的博客
12-16 3714
二叉树的前序、中序、后序及层序全遍历方式，及递归求解树高（深度）和而叶子结点的个数全代码
二叉树---求树的叶子个数
qq_51622961的博客
05-03 235
int TreeLeafSize(BTNode* root) { if (root == NULL) { return 0; } if (root->left == NULL && root->right == NULL) { return 1; } return TreeLeafSize(root->left) + TreeLeafSize(root->right); }
【C语言】二叉树的三种遍历方式
qq_56615615的博客
11-25 1638
此次代码遍历的二叉树： 代码实现： #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> //树：一种非线性数据结构，由n（n>=0）个有限结点组成一个具有层次关系的集合 //节点：1. 根节点：根节点前没有前驱节点 // 2. 其余节点: 除根节点外，其余结点被
C++实现计算二叉树的叶子数量
qq_45823902的博客
05-21 517
C++实现计算二叉树的叶子数量 叶子——没有孩子的结点 代码实现如下 #include<iostream> using namespace std; struct BinaryTree { char data; BinaryTree * lchild; BinaryTree * rchild; }; //计算叶子个数 void CalculateLeave(BinaryTree * root, int*num) { if (root == NULL) { return; }
求二叉树中的叶子数
淡定从容的专栏
04-26 1331
二叉树结点结构 struct BinaryTreeNode { char m_chChildTag; //后序遍历时用于标识其最新一次访问的是左孩子还是右孩子 char m_chData; //用于遍历时存储结点字符 int m_nValue; //用于结点是整数数值的情况 BinaryTreeNode* m_pLeftChild; BinaryTreeNode* m_pRightCh
leetcode 二叉树
09-16
在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值