二叉树—98.验证二叉搜索树 108.将有序数组转换为二叉搜索树 101. 对称二叉树 235. 二叉搜索树的最近公共祖先 236. 二叉树的最近公共祖先 C++实现

已于 2023-07-11 21:36:24 修改
阅读量73 收藏
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： c++ 深度优先
于 2023-07-11 21:34:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UUUUU22/article/details/131629051
版权

文章目录

98.验证二叉搜索树

在这里插入图片描述

方法1 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:
    bool isValidBST(TreeNode* root) {
        //1.方法一 转成有序数组
        vec.clear();
        dfs(root);
        //判断数组是否有序
        for(int i=1; i<vec.size(); i++)
        {
            if(vec[i] <= vec[i-1]) return false;
        }
        return true;
    }
private:
    //二叉树转数组
    vector<int> vec;
    void dfs(TreeNode* cur)
    {
        if(cur == nullptr) return;
        dfs(cur->left);
        vec.push_back(cur->val);
        dfs(cur->right);
    }
};

方法2 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:
    bool isValidBST(TreeNode* root) {
        //2.方法二 不使用数组
        if(root == nullptr) 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;
    }
private:
    //2.方法二 不使用数组
    long long maxVal = LONG_MIN;
};

方法3 BFS 迭代法

用栈模拟，中序模拟

/**
 * 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) {
        //3.方法三 迭代法
        //中序遍历入栈 出栈时右中左顺序 栈顶元素cur小于栈顶下一个元素pre 说明不是搜索树
        stack<TreeNode*> st;
        if(root != nullptr) st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;//记录前一个节点
        while(cur != nullptr || !st.empty())
        {
            if(cur != nullptr)
            {
                st.push(cur);
                cur = cur->left;//左节点
            }
            else
            {
                cur = st.top();//中节点
                st.pop();
                if(pre != nullptr && cur->val <= pre->val) return false;
                pre = cur;//记录前一个节点
                cur = cur->right;//右节点
            }
        }
        return true;
    }
};

108.将有序数组转换为二叉搜索树

在这里插入图片描述

将有序数组以数组中间位置的节点进行分割左右区间，分别作为左右子树。

方法1 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:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        //方法1 DFS 递归 左闭右闭区间
        return dfs(nums, 0, nums.size()-1);
    }
private:
    TreeNode* dfs(vector<int>& nums, int start, int end)
    {
        if(start > end) return nullptr;
        //如果数组是偶数长度 相当于根节点取中间靠左的值
        int mid = start + ((end - start) / 2);//根节点坐标
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = dfs(nums, start, mid - 1);
        root->right = dfs(nums, mid + 1, end);
        return root;
    }
};

方法2 BFS 迭代法

三个队列模拟，一个存放遍历的节点，一个存放左区间下标，一个存放右区间下标

/**
 * 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) {
        //方法2 BFS 迭代法
        if(nums.size() == 0) return nullptr;
        TreeNode* root = new TreeNode(0);// 初始根节点

        queue<TreeNode*> quelist;// 放遍历的节点
        queue<int> queleft;// 保存左区间下标
        queue<int> queright;// 保存右区间下标
        quelist.push(root);// 根节点入队列
        queleft.push(0);// 0为左区间下标初始位置
        queright.push(nums.size() - 1);// nums.size() - 1为右区间下标初始位置

        while(!quelist.empty())
        {           
            TreeNode* cur = quelist.front(); quelist.pop();
            int left = queleft.front(); queleft.pop();
            int right = queright.front(); queright.pop();
            int mid = left + ((right - left) / 2);

            cur->val = nums[mid];//中节点
            if(left <= mid - 1)//左节点
            {
                cur->left = new TreeNode(0);
                quelist.push(cur->left);
                queleft.push(left);
                queright.push(mid - 1);
            }
            if(right >= mid + 1)//右节点
            {
                cur->right = new TreeNode(0);
                quelist.push(cur->right);
                queleft.push(mid + 1);
                queright.push(right);
            }
        }
        return root;
    }
};

101. 对称二叉树

在这里插入图片描述

比较左右子树，需要考虑四种情况

  1. 左右节点都空
  2. 左节点为空 右节点不空 或者 左节点不空 右节点空
  3. 左右节点都不空 节点值不相同
  4. 左右节点不空且数值相等

方法1 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:
    bool isSymmetric(TreeNode* root) {
        //方法1 dfs 后序遍历
        if(root == nullptr) return true;
        return dfs(root->left, root->right);
    }
private:
    //方法1 dfs 后序遍历
    bool dfs(TreeNode* left, TreeNode* right)
    {
        //四种情况
        //1.左右节点都空
        //2.左节点为空 右节点不空  或者  2.左节点不空 右节点空
        if(!left && !right) return true;
        else if(!left || !right) return false;
        //3.左右节点都不空 节点值不相同
        else if(left->val != right->val) return false;
        //4.左右节点不空且数值相等
        //外侧节点相同 内侧节点相同
        bool outsize = dfs(left->left, right->right);
        bool inside = dfs(left->right, right->left);
        return outsize && inside;//内外侧节点都相同才是对称树
    }
};

方法2 BFS 迭代法

队列实现

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

        //方法2 bfs 队列
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty())
        {
            TreeNode* leftcur = que.front(); que.pop();
            TreeNode* rightcur = que.front(); que.pop();
            if(!leftcur && !rightcur) return true;
            if(!leftcur || !rightcur || leftcur->val != rightcur->val) return false;
            que.push(leftcur->left);
            que.push(rightcur->right);
            que.push(leftcur->right);
            que.push(rightcur->left);
        }
        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 isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;

        //方法2 bfs 栈
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty())
        {
            TreeNode* leftcur = st.top(); st.pop();
            TreeNode* rightcur = st.top(); st.pop();
            if(!leftcur && !rightcur) continue;
            if(!leftcur || !rightcur || (leftcur->val != rightcur->val)) return false;
            st.push(leftcur->left);
            st.push(rightcur->right);
            st.push(leftcur->right);
            st.push(rightcur->left);
        }
        return true;
    }
};

235. 二叉搜索树的最近公共祖先

在这里插入图片描述

利用二叉搜索树的有序性，三种情况
在[p->val, q->val]区间中
在[p->val, q->val]区间左边
在[p->val, q->val]区间右边

方法1 DFS 递归法

/**
 * 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* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //方法1 DFS 递归法
        return dfs(root, p, q);
    }
private:
    TreeNode* dfs(TreeNode* cur, TreeNode* p, TreeNode* q)
    {
        if(cur == nullptr) return cur;//中节点
        if(cur->val > p->val && cur->val > q->val)//目标在左子树
        {
            TreeNode* left = dfs(cur->left, p, q);
            if(left) return left;
        }
        if(cur->val < p->val && cur->val < q->val)
        {
            TreeNode* right = dfs(cur->right, p, q);
            if(right) return right;
        }
        return cur;
    }
};

方法2 BFS 迭代法

/**
 * 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* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //方法2 BFS 迭代法
        while(root)
        {
            if(root->val > p->val && root->val > q->val) root = root->left;
            else if(root->val < p->val && root->val < q->val) root = root->right;
            else return root;
        }
        return nullptr;
    }
};

236. 二叉树的最近公共祖先

在这里插入图片描述

  1. 情况1：如果一个节点，左子树是节点p，右子树是节点q，或者左子树是节点q，右子树是节点p，那么该节点就是节点p和q的最近公共祖先
  2. 情况2：节点本身p(q)，它拥有一个子孙节点q§，那么节点p(q)就是节点p和q的最近公共祖先
  3. 上述情况，相当于遇到 q 或者 p 就返回，返回值不为空，就说明找到了q或者p
  4. 遍历整棵树，从下往上遍历，后序遍历
/**
 * 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* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root || root==p || root==q) return root;
        //后序遍历 遍历整棵树
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(left && right) return root;//左右子树不为空 父节点就是最近祖先
        else if(!left && right) return right;//左空 右不空 返回右
        else if(left && !right) return left;//右空 左不空 返回左
        return NULL;
    }
};

相关题目的二叉树总结点

1. 二叉树遍历方式：

  • 深度优先遍历DFS
    • 前序遍历（递归法，迭代法）
    • 中序遍历（递归法，迭代法）
    • 后序遍历（递归法，迭代法）
  • 广度优先遍历BFS：层次遍历（迭代法）

2. 二叉树返回值：

递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

  • 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值——113.路径总和Ⅱ
  • 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值——236. 二叉树的最近公共祖先
  • 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回——112. 路径总和

3. 二叉搜索树具有如下特征：

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

4. 二叉搜索树的应用： 与有序数组的转化、验证二叉搜索树、与平衡树的转化

5. 二叉平衡树的特征： 一棵二叉搜索树中，每个节点的两棵子树高度差不超过 1

6. 完美二叉树的特征 ——题116

虚假自律就会真自律！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode98. 验证二叉搜索树
12-20
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。...
LeetCode精选TOP面试题108.将有序数组转换为二叉搜索树
02-15
题目描述 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的...将有序数组转换为二叉搜索树的结果肯定是不唯一的，因为存在多种建树方法。
【代码随想录训练营】【Day23】第六章｜二叉树｜669. 修剪二叉搜索树 ｜108.将有序数组转换为二叉搜索树｜538.把二叉搜索树转换为累加树
士多啤梨先生の博客
02-25 1273
【代码随想录训练营】【Day23】第六章｜二叉树｜669. 修剪二叉搜索树 ｜108.将有序数组转换为二叉搜索树｜538.把二叉搜索树转换为累加树
二叉树part09 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树
2301_76352433的博客
12-21 379
108.将有序数组转换为二叉搜索树。538.把二叉搜索树转换为累加树。669. 修剪二叉搜索树。
leetcode108. 将有序数组转换为二叉搜索树
听雪楼
12-17 564
题目 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定有序数组: [-10,-3,0,5,9], 一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 0 / \ -3 9 / / -10...
leetcode 108. 将有序数组转换为二叉搜索树（二叉搜索树）
行走巨人国
05-17 602
题目描述: 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 示例: 给定有序数组: [-10,-3,0,5,9], 一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 0 / \ -3 9 ...
算法打卡day20|二叉树篇09|Leetcode 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
改变从现在开始
03-18 887
JAVA算法|二叉树篇09|Leetcode 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
Day 23 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树 总结篇
qq_46025584的博客
04-12 1062
​ 遍历和迭代的思想都要熟悉；
⭐算法入门⭐《二叉树 - 二叉搜索树》简单02 —— LeetCode 98. 验证二叉搜索树
英雄哪里出来
09-08 3906
《二叉树 - 二叉搜索树》简单02 —— LeetCode 98. 验证二叉搜索树
Leetcode刷题java之108. 将有序数组转换为二叉搜索树
逆水行舟，不进则退
08-13 804
执行结果： 通过 显示详情 执行用时 :2 ms, 在所有 Java 提交中击败了78.64% 的用户 内存消耗 :38.3 MB, 在所有 Java 提交中击败了47.48%的用户 题目： 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定有序数组: [-10,...
代码随想录第23天| 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树
lilith_2001的博客
03-28 1139
3、确定单层递归的逻辑：如果根节点的值小于区间的左边界的值，则递归右子树，返回右子树符合条件的头节点；刚开始想得很简单，就是把左节点和区间的最小值比较，右节点和区间最大值比较，也算利用了二叉搜索树的特点，但是后来反应过来不能这样粗暴地一分为二，因为左节点连接的右子树上可能有在区间内的值，右节点连接的左子树可能有在区间内的值。如果是偶数（n）个节点，就求第（n+1)/2位置的数为中位数，中位数为根节点，左区间的中位数为左节点，右区间的中位数为右节点，不断递归得最终的平衡二叉搜索树。
java - 108. 将有序数组转换为二叉搜索树
Gnikay的博客
04-08 1061
一、题目 给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。 高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。 输入：nums = [-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5] 解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案： 二、思路 * 1 每次取数组的中间位置作为root，数组中root索引左边的作为左子树，右边...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
用c语言编写的数据结构相关的二叉树的二叉搜索
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
本文实例讲述了C语言判定一棵二叉树是否为二叉搜索树的方法。分享给大家供大家参考，具体如下： 问题 给定一棵二叉树，判定该二叉树是否是二叉搜索树（Binary Search Tree）？ 解法1:暴力搜索 首先说明一下二叉树和...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 622
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
最新发布
Joseit的博客
05-16 591
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 706
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 408
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
cpp 升序数组转换为高度平衡二叉搜索树
05-28
将一个升序数组转换为高度平衡的二叉搜索树，可以采用递归的方式来实现。 具体步骤如下： 1. 找到数组的中间元素，作为二叉搜索树的根节点。 2. 将数组分成左右两个子数组，左子数组中的元素都小于根节点，右子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值