2021-11-09每日刷题打卡

最新推荐文章于 2022-08-03 22:14:38 发布

你好_Ä

最新推荐文章于 2022-08-03 22:14:38 发布

阅读量129

点赞数

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/fnmdpnmsl/article/details/121224514

版权

2021-11-09每日刷题打卡

力扣——二叉搜索树

938. 二叉搜索树的范围和

给定二叉搜索树的根结点 root，返回值位于范围 [low, high] 之间的所有结点的值的和。

示例 1：

bst1.jpg (542×301) (leetcode.com)

输入：root = [10,5,15,3,7,null,18], low = 7, high = 15
输出：32

遍历一遍二叉树，用一个全局变量sum来计算结果，每遍历一个节点，判断该节点的值是否在 [low, high] 范围内，如果在就加到sum上。遍历完后返回sum即可。

/**
 * 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 sum=0;
    int down=0;
    int up=0;
    int rangeSumBST(TreeNode* root, int low, int high) {
        down=low;
        up=high;
        dfs(root);
        return sum;
    }
    void dfs(TreeNode* root)
    {
        if(!root)return;
        if(root->val >= down&&root->val <= up)
            sum+=root->val;
        dfs(root->left);
        dfs(root->right);
    }
};

530. 二叉搜索树的最小绝对差和783. 二叉搜索树节点最小距离

给你一个二叉搜索树的根节点 root ，返回树中任意两不同节点值之间的最小差值。

差值是一个正数，其数值等于两值之差的绝对值。

示例 1：

bst1.jpg (292×301) (leetcode.com)

输入：root = [4,2,6,1,3]
输出：1

中序遍历一遍二叉树，把结果存在vector容器v里，然后从下标1开始到结尾，每次计算v[i]-v[i-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:
    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*>sta;
        vector<int>v;
        while(root||sta.size())
        {
            while(root)
            {
                v.push_back(root->val);
                sta.push(root);
                root=root->left;
            }
            root=sta.top();
            sta.pop();
            root=root->right;
        }
        int min=INT_MAX,n=v.size();
        sort(v.begin(),v.end());
        for(int i=1;i<n;i++)
        {
            if(min>(v[i]-v[i-1]))
                min=(v[i]-v[i-1]);
        }
        return min;
    }
};

剑指 Offer 54. 二叉搜索树的第k大节点

给定一棵二叉搜索树，请找出其中第k大的节点。

示例 1:

输入: root = [3,1,4,null,2], k = 1
3
/
1 4

2
输出: 4

把树的中序序列保存到vector容器v中，返回v[v.size()-k]即可。

/**
 * 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:
    vector<int>v;
    int kthLargest(TreeNode* root, int k) {
        dfs(root);
        return v[v.size()-k];
    }
    void dfs(TreeNode*root)
    {
        if(!root)return;
        dfs(root->left);
        v.push_back(root->val);
        dfs(root->right);
    }
};

897. 递增顺序搜索树和剑指 Offer II 052. 展平二叉搜索树

给你一棵二叉搜索树，请你按中序遍历将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。

示例 1：

ex1.jpg (1201×701) (leetcode.com)

输入：root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

把中序序列存在vector容器v中，再根据v的值逐步创建树。

/**
 * 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>v;
    TreeNode* increasingBST(TreeNode* root) {
        dfs(root);
        TreeNode*p;
        int i=0;
        dfs2(p,i);
        return p;
    }
    void dfs(TreeNode*root)
    {
        if(!root)return;
        dfs(root->left);
        v.push_back(root->val);
        dfs(root->right);
    }
    void dfs2(TreeNode*&p,int &i)
    {
        if(i>=v.size())return;
        p=new TreeNode(v[i++]);
        dfs2(p->right,i);
    }
};

另一种方法就是在中序遍历的时候改变它的指向，让他直接变成我们要的树。

准备一个全局的树节点p做开头，函数里先初始化一个头结点q，让这个头结点指向p，开始递归，递归的过程和中序遍历一样，只不过中间的地方我们不是存值，而是要把p->right=root，再把root的左节点指向空，以免形成环，再把p往下走一格。

当递归完后，返回q->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 {
private:
    TreeNode * p;
public:
    TreeNode* increasingBST(TreeNode* root) {
        TreeNode * q=new TreeNode(-1);
        p=q;
        dfs(root);
        return q->right;
    }
    void dfs(TreeNode*root)
    {
        if(!root)return;
        dfs(root->left);
        
        p->right=root;
        root->left=nullptr;
        p=root;

        dfs(root->right);
    }
    

};