[代码随想录]二叉树篇

已于 2023-10-11 19:17:48 修改
阅读量87 收藏
点赞数
分类专栏： OJ 文章标签： c++
于 2023-10-11 19:14:22 首次发布
附上ID和原文链接即可
本文链接：https://blog.csdn.net/sewerperson/article/details/133363849
版权

文章目录

1. 二叉树之层序遍历

1.1 144-二叉树的前序遍历

144
在这里插入图片描述

/**
 * 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:
    void Recursion(TreeNode* root,vector<int>& ans)
    {
        if(root == nullptr)
            return;
        ans.push_back(root->val);
        Recursion(root->left,ans);
        Recursion(root->right,ans);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        Recursion(root,ans);
        return ans;
    }
};

迭代难度更大

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur || !st.empty())
        {
            while(cur) //第一趟把左列节点放入栈和ans
            {
                ans.push_back(cur->val);
                st.push(cur);
                cur = cur->left;
            }
            TreeNode* tmp = st.top(); //对应着左下角的节点
            st.pop();
            cur = tmp->right; //开始右
        }
        return ans;
    }
};

1.2 94-二叉树的中序遍历

94
在这里插入图片描述

class Solution {
public:
    void Recursion(TreeNode* root,vector<int>& ans)
    {
        if(root == nullptr)
            return;
        Recursion(root->left,ans);
        ans.push_back(root->val);
        Recursion(root->right,ans);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        Recursion(root,ans);
        return ans;
    }
};

迭代法

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        TreeNode* cur = root;
        while(cur || !st.empty())
        {
            while(cur)
            {
                //ans.push_back(cur->val); 并不是最左边的数据放在第一个
                st.push(cur);
                cur = cur->left;
            }
            TreeNode* tmp = st.top();
            ans.push_back(tmp->val); 
            st.pop();
            cur = tmp->right;
        }
    }
};

1.3 145-二叉树的后序遍历

145

在这里插入图片描述

class Solution 
{
public:
    void Recursion(TreeNode*& root,vector<int>& ans)
    {
        if(root==nullptr)
            return;
        Recursion(root->left,ans);
        Recursion(root->right,ans);
        ans.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) 
    {
        vector<int> ans;
        Recursion(root,ans);
        return ans;
    }
};

迭代法

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* prev = nullptr;
        while(cur || !st.empty())
        {
            while(cur)
            {
                st.push(cur);
                cur=cur->left;
            }
            TreeNode* top = s.top();
            if(!top->right || top->right == prev)
            {
                ans.push_back(top->val);
                prev = top;
                st.pop();
            }
            else
                cur = top->right; //当左走完之后这一步可以走到右
        }
        return ans;
    }
};

1.4 102-二叉树的层序遍历

102

在这里插入图片描述

class Solution {
public:
    void Recursion(vector<vector<int>>& ans,TreeNode* root,int level)
    {
        if(!root)
            return;
        if(ans.size() <= level) //ans的层数不够,加层数
            ans.push_back(vector<int>());
        ans[level].push_back(root->val);
        Recursion(ans,root->left,level+1);
        Recursion(ans,root->right,level+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        Recursion(ans,root,0);
        return ans;
    }
};

1.5 107-二叉树的层序遍历II

107

在这里插入图片描述

上一题reverse一下就可以了

class Solution {
public:
    void Recursion(vector<vector<int>>& ans,TreeNode* root,int level)
    {
        if(!root)
            return;
        if(ans.size() <= level)
            ans.push_back(vector<int>());
        ans[level].push_back(root->val);
        Recursion(ans,root->left,level+1);
        Recursion(ans,root->right,level+1);
    }
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ans;
        Recursion(ans,root,0);
        reverse(ans.begin(),ans.end());
        return ans;
    }
};

也引入一下这题(上一题)的非递归写法

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root); //先放一个根节点
        vector<vector<int>> result;
        while (!que.empty()) 
        {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) 
            {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val); //从前往后一个一个取
                if (node->left) 
                    que.push(node->left); //push进去当前层的下一层节点
                if (node->right) 
                    que.push(node->right); //同理
            }
            result.push_back(vec); //加入一层
        }
        reverse(result.begin(), result.end()); // 在这里反转一下数组即可
        return result;

    }
};

1.6 199-二叉树的右视图

199
在这里插入图片描述

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> ans;
        if(root) //加入第一个节点
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size;i++)
            {
                TreeNode* tmp = que.front();
                que.pop();
                if(i == (size-1)) //如果是位于尾部
                    ans.push_back(tmp->val);
                if(tmp->left)
                    que.push(tmp->left);//加入下一层数据
                if(tmp->right)
                    que.push(tmp->right);
            }
        }
        return ans;
    }
};

1.7* 637-二叉树的层平均值

637

在这里插入图片描述

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> ans;
        if(root)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            double sum = 0;
            for(int i = 0; i < size; ++i)
            {
                TreeNode* tmp = que.front();
                que.pop();
                sum+=tmp->val;

                if(tmp->left)
                    que.push(tmp->left);
                if(tmp->right)
                    que.push(tmp->right);
            }
            ans.push_back(sum/size);
        }
        return ans;
    }
};

1.8* 429-N叉树的层序遍历

429

在这里插入图片描述
在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> ans;
        if(root)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int> tmp_v;
            for(int i = 0; i < size; ++i)
            {
                Node* node = que.front();
                que.pop();
                tmp_v.push_back(node->val);

                for(int j = 0; j < node->children.size(); ++j) //下一层节点加入que
                    if(node->children[j])
                        que.push(node->children[j]);
            }
            ans.push_back(tmp_v);
        }
        return ans;
    }
};

1.9 515-在每个树行中找最大值

515

在这里插入图片描述

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> ans;
        queue<TreeNode*> que;
        if(root)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            int max = INT_MIN;
            for(int i = 0; i < size;++i)
            {
                TreeNode* tmp = que.front();
                que.pop();
                if(tmp->val>max)
                    max = tmp->val;
                if(tmp->left)
                    que.push(tmp->left);
                if(tmp->right)
                    que.push(tmp->right);
            }
            ans.push_back(max);
        }
        return ans;
    }
};

1.10* 116-填充每个节点的下一个右侧节点指针

116

在这里插入图片描述

在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(!root)
            return nullptr;
        Node* leftest = root;
        while(leftest->left) //如果该节点还有子节点,则说明可以进入循环处理其孩子
        {
            Node* cur = leftest;
            while(cur) //处理cur所有的子节点连接 
            {
                cur->left->next = cur->right; //下一层的next连接
                if(cur->next)
                    cur->right->next = cur->next->left; //下一层隔支连接
                cur = cur->next;
            }
            leftest = leftest->left; //下一层最左边开始
        }
        return root;
    }
};

若使用普通的层序遍历那么空间复杂度会达到N
而这种方式空间复杂度为1

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

117

在这里插入图片描述
在这里插入图片描述

上一题是完全二叉树

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(root && (root->left || root->right)) //root存在并且必须有一个孩子
        {
            if(root->left && root->right) //如果有左有右,则连接孩子
                root->left->next = root->right;

            //准备让孩子隔支连接
            Node* child = root->right ? root->right : root->left;
            Node* brodady = root->next; //向右移动以便用孩子连接child
            while(brodady && !(brodady->left||brodady->right)) //直到brodady走到尽头,也要找到有孩子的brodady
                brodady = brodady->next;

            child->next = brodady ? (brodady->left ? brodady->left : brodady->right) : nullptr;
            connect(root->right); //先向右初始化出NULL
            connect(root->left);
        }
        return root;
    }
};

1.12 104-二叉树的最大深度

104

在这里插入图片描述

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

1.13 111-二叉树的最小深度

111
在这里插入图片描述

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)
            return 0;
        if(!root->left && !root->right)
            return 1;
        
        int min_depth = INT_MAX;
        if(root->left)
            min_depth = min(minDepth(root->left),min_depth);
        if(root->right)
            min_depth = min(minDepth(root->right),min_depth);
        return min_depth+1;
    }
};

2. 二叉树之常见算法

2.1 226-翻转二叉树

226
在这里插入图片描述

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

2.2 101-对称二叉树

101

在这里插入图片描述
在这里插入图片描述

递归

class Solution {
public:
    bool Recursion(TreeNode* left,TreeNode* right)
    {
        if(!left&&right || left&&!right) //如果长短不一
            return false;
        if(!left && !right) //如果都没有后续了
            return true;
        if(left->val != right->val)
            return false;
        return Recursion(left->left,right->right) &&
                Recursion(left->right,right->left); 
                //对称的两个节点比较
    }
    bool isSymmetric(TreeNode* root) {
        return Recursion(root->left,root->right);
    }
};

迭代(栈)

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);
        while (!st.empty()) 
        {
            TreeNode* leftNode = st.top(); 
            st.pop();
            TreeNode* rightNode = st.top(); 
            st.pop();
            if (!leftNode && !rightNode) //左右节点都不存在,相当于对称,循环至下一次判断
                continue;
            
            //左右不一样长 || 左右节点的值不一样
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) 
                return false;
            
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};

2.3* 222-完全二叉树的节点个数

222

在这里插入图片描述
在这里插入图片描述

递归遍历 O(N)

class Solution {
public:
    void Recursion(TreeNode* root,int& count)
    {
        if(!root)
            return;
        count++;
        Recursion(root->left,count);
        Recursion(root->right,count);
    }
    int countNodes(TreeNode* root) {
        int count = 0;
        Recursion(root,count);
        return count;
    }
};

精简版递归

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == NULL) 
            return 0;
        return 1 + countNodes(root->left) 
                + countNodes(root->right);
    }
};

最优

class Solution {
public:
    int countNodes(TreeNode* root) 
    {
        if (!root)
            return 0;
        int level = 0;
        TreeNode* cur = root;
        while (cur->left) 
        {
            level++;
            cur = cur->left;
        }
        int low = 1 << level; // 层序遍历第low位为最深层最左侧节点序号 4
        int high = (1 << (level + 1)) - 1; //层序遍历第high位为最深层最右侧节点序号 7
        while (low < high) 
        {
            int mid = (high - low + 1) / 2 + low; //+1防止low+0 ,mid为两节点中间部分一个节点,偏右
            if (exists(root, level, mid))
                low = mid;
            else
                high = mid - 1;
        }
        return low;
    }

    bool exists(TreeNode* root, int level, int mid) //6
    {
        int bits = 1 << (level - 1); //上一层的第一位序列
        TreeNode* cur = root;
        while (cur && bits > 0) 
        {
            if (bits & mid)  //0010 0110 0010 当不再同一树时判断后就进入循环
                cur = cur->right;
            else
                cur = cur->left;
            bits >>= 1; //bits是最左节点,往上靠
        }
        return cur != nullptr;
    }
};

时间复杂度:O(logN*logN)
空间复杂度:O(1)

2.4 110-平衡二叉树

110
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int Recursion(TreeNode* root)
    {
        if(!root)
            return 0;
        int left = Recursion(root->left);
        if(left == -1)
            return -1;
        int right = Recursion(root->right);
        if(right == -1)
            return -1;
        if(abs(left-right) > 1)
            return -1; //执行后,以后的结果都为-1,递归其实已经可以看作结束了
        return left>right?left+1:right+1; //每一层都会记录层数+1
    }
    bool isBalanced(TreeNode* root) 
    {
        if(Recursion(root) == -1)
            return false;
        return true;   
    }
};

2.5 257-二叉树的所有路径

257
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    void Recursion(TreeNode* root,vector<string>& vs,string s) //s传的是临时拷贝份
    {
        if(root&&!root->left&&!root->right) //无子,此时不加->
        {
            s+=(to_string(root->val));
            vs.push_back(s);
            return;
        }
        if(!root)
            return;
        s+=(to_string(root->val)+"->");
        Recursion(root->left,vs,s); 
        Recursion(root->right,vs,s); 
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> vs;
        string s;
        Recursion(root,vs,s);
        return vs;
    }
};

2.6 404-左子叶之和

404
在这里插入图片描述

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if (!root) 
            return 0;
        int leftValue = 0;
        if (root->left && !root->left->left && !root->left->right) //左子存在且为叶
            leftValue = root->left->val;
        
        return leftValue + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
    }
};

2.7* 513-找树左下角的值

513

在这里插入图片描述
在这里插入图片描述

dfs

class Solution {
public:
    void Recursion(TreeNode* cur,int curdep,int& maxdep,int& ans)
    {
        if(!cur->left&&!cur->right)
        {
            if(curdep>maxdep)
            {
                maxdep = dep;
                ans = cur->val;
            }
            return;
        }
        if(cur->left) //cur->left在前面使得更早的占用ans,以防被right占用
            Recursion(cur->left,dep+1,maxdep,ans);
        if(cur->right)
            Recursion(cur->right,dep+1,maxdep,ans);
    }
    int findBottomLeftValue(TreeNode* root) {
        int ans = root->val;
        int maxdep = 0;
        Recursion(root,0,maxdep,ans);
        return ans;
    }
};

bfs

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        int ans = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            TreeNode* cur = que.front();
            que.pop();
            if(cur->right)
                que.push(cur->right);
            if(cur->left)
                que.push(cur->left);
            ans = cur->val;
        }
        return ans;
    }
};

2.8 112-路径总和

112

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool Recursion(TreeNode* cur,int sum,int target)
    {
        if(!cur)
            return false;
        if(!cur->left&&!cur->right&&sum+cur->val == target)
            return true;
        
        return Recursion(cur->left,sum+cur->val,target)
            ||Recursion(cur->right,sum+cur->val,target);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        return Recursion(root,0,targetSum);
    }
};

2.9* 106-从中序与后续遍历序列构造二叉树

106

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* Recursion(vector<int>& inorder,vector<int>& postorder,int& rootindex,int left,int right)
    {
        if(left > right)
            return nullptr;
        TreeNode* cur = new TreeNode(postorder[rootindex]); //cur为当前根节点
        int mid = 0;
        for(mid = inorder.size()-1 ; mid >=0 ; --mid)
            if(inorder[mid] == postorder[rootindex])
                break;
        //此时mid为inorder的根坐标
        rootindex--; //跳到下一个根
        //因为是后序所以先right,否则会出现构建出相反的树,并且大概率导致rootindex<0而导致的越栈
        cur->right = Recursion(inorder,postorder,rootindex,mid+1,right);
        cur->left = Recursion(inorder,postorder,rootindex,left,mid-1);
        return cur;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int rootindex = postorder.size() - 1;
        return Recursion(inorder,postorder,rootindex,0,rootindex);
    }
};

2.10* 105-从前序与中序遍历序列构造二叉树

105
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* Recursion(vector<int>& preorder, vector<int>& inorder,int& rootindex,int left , int right)
    {
        if(left > right)
            return nullptr;
        TreeNode* cur = new TreeNode(preorder[rootindex]);
        int mid = 0;
        for(mid = 0 ; mid < inorder.size() ; ++mid)
            if(inorder[mid] == preorder[rootindex])
                break;
        rootindex++;
        cur->left = Recursion(preorder,inorder,rootindex,left,mid-1);
        cur->right = Recursion(preorder,inorder,rootindex,mid+1,right);
        return cur;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int rootindex = 0;
        return Recursion(preorder,inorder,rootindex,0,preorder.size()-1);
    }
};

2.11* 654-最大二叉树

654

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* Recursion(vector<int>& nums,int left,int right)
    {
        if(left > right)
            return nullptr;
        int mid = left; //坐标
        int max = 0;    //最大值
        for(int i = mid ; i <= right ; ++i)
        {
            if(nums[i] > max)
            {
                mid = i;       //mid就是根的坐标
                max = nums[i]; //最大值就是根
            }
        }
        TreeNode* cur = new TreeNode(max); //构建根
        cur->left = Recursion(nums,left,mid-1);
        cur->right = Recursion(nums,mid+1,right);
        return cur;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return Recursion(nums,0,nums.size()-1);
    }
};

2.12 617-合并二叉树

617

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1)
            return root2; //如果两个节点都不存在,也会返回nullptr(root2)
        if(!root2)
            return root1;
        TreeNode* root = new TreeNode(root1->val+root2->val);
        root->left = mergeTrees(root1->left,root2->left);
        root->right = mergeTrees(root1->right,root2->right);
        return root;
    }
};

2.13* 236-二叉树的最近公共祖先

236

在这里插入图片描述

在这里插入图片描述

/**
 * 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)
            return nullptr;
        if(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;
        else
            return nullptr;
    }
};

3. 二叉搜索树

3.1 700-二叉搜索树中的搜索

700

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(!root)
            return nullptr;
        if(val < root->val)
            return searchBST(root->left,val);
        else if(val > root->val)
            return searchBST(root->right,val);
        else
            return root;
    }
};

3.2* 98-验证二叉搜索树

98

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool isValidBST(TreeNode* root,TreeNode* minNode = nullptr,TreeNode* maxNode = nullptr) {
        if(!root)
            return true;
        if((minNode && root->val <= minNode->val) || //右树用来判断是否比父小
            (maxNode && root->val >= maxNode->val))  //左树用来判断是否比父大
            return false;                            //不符合就false
            
        return isValidBST(root->left,minNode,root) && //对于左树,最大的就是根
                isValidBST(root->right,root,maxNode); //对于右树,最小的就是根
    }
};

更直观的方法

class Solution {
public:
    bool isValidBST(TreeNode* root) 
    {
        if(!root)
            return true;
        if(root->left)
        {
            TreeNode* tmp = root->left;
            if(tmp->val>=root->val) //先判断和父的关系是否满足
                return false;
            while(tmp->right)       //在判断自己的右孩子是否和自己对应
            {                       //左孩子会通过递归(和父的关系)进行判断
                tmp = tmp->right;
                if(tmp->val>=root->val)
                    return false;
            }
        }
        if(root->right)
        {
            TreeNode* tmp = root->right;
            if(tmp->val<=root->val)
                return false;
            while(tmp->left)
            {
                tmp = tmp->left;
                if(tmp->val<=root->val)
                    return false;
            }
        }
        return isValidBST(root->left) && isValidBST(root->right);
    }
};

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

530

在这里插入图片描述
在这里插入图片描述

递归

class Solution {
public:
    void Recursion(TreeNode* root,TreeNode*& prev,int& mindif)
    {
        if(!root)
            return;
        Recursion(root->left,prev,mindif);
        if(prev)
            mindif = min(mindif,abs(root->val-prev->val));
            
        prev = root; //prev就是更深层的
        Recursion(root->right,prev,mindif);
    }
    int getMinimumDifference(TreeNode* root) 
    {
        int mindif = INT_MAX;
        TreeNode* prev = nullptr;
        Recursion(root,prev,mindif); //类似于采取中序遍历寻找mindif
        return mindif;
    }
};

完全遍历

class Solution {
public:
    void Recursion(TreeNode* root,int& min)
    {
        if(!root)
            return;
        int tmp;
        if(root->left)
        {
            TreeNode* left = root->left;
            while(left)
            {
                tmp =abs(root->val-left->val);
                if(tmp<min)
                    min = tmp;
                left = left->right;
            }
        }
        if(root->right)
        {
            TreeNode* right = root->right;
            while(right)
            {
                tmp = abs(root->val-right->val);
                if(tmp<min)
                    min = tmp;
                right = right->left;
            }
        }
        Recursion(root->left,min);
        Recursion(root->right,min);
    }
    int getMinimumDifference(TreeNode* root) 
    {
        int min = 100000;
        Recursion(root,min);
        return min;
    }
};

3.4 501-二叉搜索树中的众数

501

在这里插入图片描述
在这里插入图片描述

hash通解,即非二叉树也可解

class Solution {
public:
    void Init_um_Recursion(TreeNode* root,unordered_map<int,int>& um)
    {
        if(!root)
            return;
        um[root->val]++;
        Init_um_Recursion(root->left,um);
        Init_um_Recursion(root->right,um);
    }
    vector<int> findMode(TreeNode* root) {
        unordered_map<int,int> um;
        Init_um_Recursion(root,um);

        vector<int> ans;
        int max = INT_MIN;
        for(auto& e : um) //算出最多的出现次数
            if(e.second > max)
                max = e.second;

        for(auto& e : um)
            if(e.second == max)
                ans.push_back(e.first);
        
        return ans;
    }
};

针对

/**
 * 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 samenum = 0;
    int count = 0;
    int maxcount = 0;
    void Get_ret(TreeNode* root,vector<int>& ret)
    {
        if(!root)
            return;
        Get_ret(root->left,ret);
        ret.push_back(root->val);

        if(samenum == root->val) //即使samenum初始值就和val相同也无所谓
            count++;
        else
        {
            samenum = root->val;
            count=1; //避免samenum初始就和val相同而导致的错误计数,也方便使用
        }

        if(maxcount < count)
            maxcount = count;
        Get_ret(root->right,ret);
    }
    
    vector<int> findMode(TreeNode* root) {
        vector<int> ans;
        vector<int> ret;
        Get_ret(root,ret);

        int left = 0;
        int right = maxcount-1; //left到right 可看作是窗口
        while(right < ret.size())
        {
            if(ret[left] == ret[right])
            {
                ans.push_back(ret[left]);
                left = right+1;
                right = left+maxcount-1;
            }
            else
            {
                left++;
                right++;
            }
        }
        return ans;
    }
};

3.5* 235-二叉搜索树的最近公共祖先

235

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        if(!root)
            return nullptr;
        if(root->val > p->val && root->val > q->val) //都在根右边
            return lowestCommonAncestor(root->left,p,q);
        else if(root->val<p->val&&root->val<q->val)
            return lowestCommonAncestor(root->right,p,q);
        return root;
    }
};

3.6* 701-二叉搜索树中的插入操作

701

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(!root)
            return new TreeNode(val);
        if(val > root->val)
            root->right = insertIntoBST(root->right,val);
        else if(val < root->val)
            root->left = insertIntoBST(root->left,val);
        return root;
    }
};

3.7* 450-删除二叉搜索树中的节点

450

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* findMin(TreeNode* node) 
    {
        while (node->left) 
            node = node->left;
        return node;
    }

    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) 
            return root;

        if (key < root->val) 
            root->left = deleteNode(root->left, key);
        else if (key > root->val) 
            root->right = deleteNode(root->right, key);
        else 
        {
            if (!root->left) 
            {
                TreeNode* temp = root->right;
                delete root;
                return temp;
            }
            else if (!root->right) 
            {
                TreeNode* temp = root->left;
                delete root;
                return temp;
            }

            TreeNode* temp = findMin(root->right); //temp就是要替代的节点
            root->val = temp->val;
            root->right = deleteNode(root->right, temp->val);
        }
        return root;
    }
};

3.8* 669-修剪二叉搜索树

669

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) 
    {
        if(!root)
            return nullptr; //间接删除
        if(root->val<low) //范围全在右子树上
            return trimBST(root->right,low,high);
        if(root->val>high)
            return trimBST(root->left,low,high);
            
        root->left = trimBST(root->left,low,high);
        root->right = trimBST(root->right,low,high);
        return root;
    }
};

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

108

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    TreeNode* Recursion(vector<int>& nums,int left,int right)
    {
        if(left>right)
            return nullptr;
        int mid = left+((right-left)>>1); // >>1 可看作是 /2,默认左偏
        TreeNode* newnode = new TreeNode(nums[mid]);
        newnode->left = Recursion(nums,left,mid-1);
        newnode->right = Recursion(nums,mid+1,right);
        return newnode;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) 
    {
        return Recursion(nums,0,nums.size()-1);
    }
};

3.10 538-把二叉搜索树转换为累加树

538

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    void Recursion(TreeNode* root,int& val)
    {
        if(!root)
            return;
        Recursion(root->right,val);
        val+=root->val;
        root->val = val;
        Recursion(root->left,val);
    }
    TreeNode* convertBST(TreeNode* root) {
        int val = 0;
        Recursion(root,val);
        return root;
    }
};
nitesy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树 - 代码随想录
qq_40808423的博客
02-25 675
1.二叉树基础理论 1. 二叉树的种类 主要分为：满二叉树和完全二叉树两种形式。 满二叉树 如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树，如图所示。 完全二叉树 在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h -1 个节点。 eg：优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。 .
代码随想录算法训练营第十四天 | 二叉树
weixin_70370923的博客
11-08 280
代码随想录算法训练营第十四天 | 二叉树
Leetcode Python学习记录——代码随想录二叉树篇一
weixin_47227105的博客
06-08 427
树是由n个结点组成的有限集合。二叉树不是树的特例，而是另一种不同的数据结构。高度和深度都是针对节点的概念。根节点的高度就是二叉树的最大深度。 隐式回溯 用path[:]传递变量可以传递一个副本，并不修改原path，则实现同样的效果。 python 定义 N叉树 遍历 for i,j in zip(range(),range()):abs()将结点加入stack之前（stack=[root]），注意检验root是否为None。 模拟时注意popleft()和pop()不要写混淆了 用完pop
【Leecode】代码随想录二叉树篇day14(对称&深度&高度）
nufe/dut/python/java开发/记录日常感悟
07-16 435
二叉树的属性（对称&深度）
【Leecode】代码随想录二叉树篇day15(二叉树属性Ⅱ（占坑未完））
nufe/dut/python/java开发/记录日常感悟
07-17 186
二叉树属性Ⅱ（a wise dog will reject to write a review survey）
代码随想录 Day14 二叉树
02-07
本篇内容主要介绍了二叉树的基本概念、`TreeNode`类的实现、二叉搜索树的基本操作（插入和遍历），以及二叉树的三种遍历方式（前序、中序、后序）。这些基础概念和技术在计算机科学的多个领域都有着广泛的应用。理解...
代码随想录-力扣刷题-总结笔记02
upward
04-04 939
代码随想录-力扣刷题-总结笔记02
代码随想录知识星球精华（第四版）最强八股文-问答精华篇.rar
03-19
《代码随想录知识星球精华（第四版）最强八股文-问答精华篇》是一部集成了编程领域深度学习和实践的资源合集，主要聚焦于软件开发中的常见问题与最佳解答。作为一本针对IT专业人士的参考资料，它囊括了软件开发、...
代码随想录知识星球精华（第四版）最强八股文-面经篇.rar
03-19
《代码随想录知识星球精华（第四版）最强八股文-面经篇》是一部集成了众多编程面试经典问题和解答的资源集合，主要面向正在准备软件开发面试的程序员们。该压缩包中的核心文件“代码随想录知识星球精华（第四版）...
代码随想录知识星球精华（第四版）最强八股文-基础篇.rar
03-19
《代码随想录知识星球精华（第四版）最强八股文-基础篇》是一份针对编程初学者和进阶者的重要资源，它汇集了丰富的IT知识，尤其在软件开发的基础概念和技术方面。这份资料主要围绕编程语言的基础知识展开，旨在帮助...
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1342
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 662
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1271
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
Linux C 内核编程 /proc 编程例子
最新发布
yong1585855343的博客
09-02 420
Linux 内核编程 /proc 例子代码
c++11新特性-智能指针
SuperYang_的博客
09-01 1141
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 310
【C++ Primer Plus习题】9.1
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 252
【代码】C++友类匿名对象，运算符重载。
《从C/C++到Java入门指南》- 26.record 类+多态
09-02 338
由于record类比较简单，将他和多态放在一节中。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 196
C++ | Leetcode C++题解之第390题消除游戏
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值