day 8二叉树

最新推荐文章于 2024-09-14 15:47:59 发布

lululiangi

最新推荐文章于 2024-09-14 15:47:59 发布

阅读量357

点赞数 9

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_73924943/article/details/140770212

版权

617. 合并二叉树

/**
 * 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==nullptr) return root2;
        if(root2==nullptr) return root1;

        //确定单层递归逻辑
        root1->val+=root2->val;
        root1->left=mergeTrees(root1->left,root2->left);
        root1->right=mergeTrees(root1->right,root2->right);
        return root1;
    }
};

迭代法：（层序遍历）

/**
 * 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==nullptr) return root2;
        if(root2==nullptr) return root1;
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);
        while(!que.empty()){
            TreeNode* node1=que.front();que.pop();
            TreeNode* node2=que.front();que.pop();
            //此时两个节点一定不为空
            node1->val+=node2->val;

            //如果两颗左子树都不为空，加入队列
            if(node1->left!=nullptr&&node2->left!=nullptr){
                que.push(node1->left);
                que.push(node2->left);
            }
            //如果两颗右子树都不为空，加入队列
            if(node1->right!=nullptr&&node2->right!=nullptr){
                que.push(node1->right);
                que.push(node2->right);
            }
            //接下来处理左右子树存在空的情况

            //1空，2不空
            if(node1->left==nullptr&&node2->left!=nullptr){
                node1->left=node2->left;
            }
            if(node1->right==nullptr&&node2->right!=nullptr){
                node1->right=node2->right;
            }
            //1不空，2空的情况不用管

        }
        return root1;
    }
};

700. 二叉搜索树中的搜索

二叉搜索树的特殊性：节点左右孩子分别小于，大于该节点

递归法：

/**
 * 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* searchBST(TreeNode* root, int val) {
        //确定终止条件
        if(root==nullptr||root->val==val) return root;

        //确定单层递归逻辑
        TreeNode* res=nullptr;
        if(root->val<val) res=searchBST(root->right,val);
        if(root->val>val) res=searchBST(root->left,val);
        return res; 
    }
};

迭代法：

/**
 * 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* searchBST(TreeNode* root, int val) {
        while(root!=nullptr){
            if(root->val<val) root=root->right;
            else if(root->val>val) root=root->left;
            else return root;
        }
        return nullptr;
    }
};

98. 验证二叉搜索树

利用二叉搜索树的特性，通过中序搜索得到数组，验证是否是递增的

/**
 * 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> vec;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;

        traversal(cur->left);
        vec.push_back(cur->val);
        traversal(cur->right);
        return;
    }
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return false;
        traversal(root);
        for(int i=0;i<vec.size()-1;i++){
            if(vec[i]>=vec[i+1]) return false;
        }
        return true;
    }
};

解法2：不用记录在数组中，可以遍历的时候就判断，不过还是要利用有序性的特性。

/**
 * 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:
    long long maxVal=LONG_MIN;//后台测试数据最小取到int最小值
    bool isValidBST(TreeNode* root) {
        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;
    }
};

解法3：直接记录上一个节点，比较两个节点对应的值。

我觉得这个还有点难理解，突然不明白为什么中序了，不明白递归了。先左递归在处理中间值再右递归。左递归到最深层，pre从最深层/最小值开始。还要记得if条件语句里面的pre加条件不为空。

/**
 * 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* pre=nullptr;
    bool isValidBST(TreeNode* root) {
        //确定终止条件
        if(root==nullptr) return true;
        //确定单层递归逻辑
        bool left=isValidBST(root->left);
        if(pre!=nullptr&&pre->val>=root->val) return false;
        pre=root;
        bool right=isValidBST(root->right);

        return left&&right;
    }
};

530. 二叉搜索树的最小绝对差

/**
 * 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> vec;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;

        traversal(cur->left);
        vec.push_back(cur->val);
        traversal(cur->right);
        return;
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        int res=INT_MAX;
        for(int i=0;i<vec.size()-1;i++){
            int chazhi=abs(vec[i]-vec[i+1]);
            if(chazhi<res) res=chazhi;
        }
        return res;
    }
};

方法2：（不用数组记录，记录上一个节点，遍历过程中直接进行比较）

/**
 * 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* pre=nullptr;
    int res=INT_MAX;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;

        traversal(cur->left);
        if(pre!=nullptr){
            res=min(res,cur->val-pre->val);
        }
        pre=cur;
        traversal(cur->right);
        return;
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return res;
    }
};

方法3：（中序迭代法）

/**
 * 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*>st;
        TreeNode*cur=root;
        TreeNode*pre=nullptr;
        int res=INT_MAX;
        while(cur!=nullptr||!st.empty()){
            if(cur!=nullptr){
                st.push(cur);
                cur=cur->left;
            }
            else{
                cur=st.top();
                st.pop();
                if(pre!=nullptr){
                    res=min(res,cur->val-pre->val);
                }
                pre=cur;
                cur=cur->right;
            }
        }
        return res;
    }
};

501. 二叉搜索树中的众数

/**
 * 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:
    unordered_map<int,int> map;
    void traversal(TreeNode* cur){
        if(cur==nullptr) return;

        map[cur->val]++;
        traversal(cur->left);
        traversal(cur->right);
        return;
    }
    bool static cmp(const pair<int,int>&a,const pair<int,int>&b){
        return a.second>b.second;
    }
    vector<int> findMode(TreeNode* root) {
        traversal(root);
        vector<pair<int,int>> vec(map.begin(),map.end());
        sort(vec.begin(),vec.end(),cmp);
        vector<int> res;
        res.push_back(vec[0].first);
        for(int i=1;i<vec.size();i++){
            if(vec[i].second==vec[0].second) res.push_back(vec[i].first);
        }
        return res;
    }
};