LeetCode 530二叉搜索树的绝对搜索差 501二叉搜索树中的众数 236二叉树的最近公共祖先 | 代码随想录25期训练营day21

LeetCode 530 二叉搜索树的绝对搜索差 2023.11.14

• 题目链接
• 代码随想录讲解[链接]
  

class Solution {
public:
    //双指针做法，中序遍历
    int min = INT_MAX;
    TreeNode* pre;
    
    void traversal(TreeNode* cur)
    {
        if(cur == NULL)
            return;
        traversal(cur->left);
        if(pre != NULL && abs(cur->val - pre->val) < min)
            min = abs(cur->val - pre->val);
        pre = cur;
        traversal(cur->right);
    }

    int getMinimumDifference(TreeNode* root) {
        //直接做法，把树值存入一个数组，给数组排序然后判断最小值
        // vector<int> num;
        // queue<TreeNode*> que;
        // que.push(root);
        // while (!que.empty())
        // {
        //     int size = que.size();
        //     while (size--)
        //     {
        //         TreeNode* node = que.front();
        //         que.pop();
        //         num.push_back(node->val);
        //         if(node->left)
        //             que.push(node->left);
        //         if(node->right)
        //             que.push(node->right);
        //     } 
        // }
        // sort(num.begin(), num.end());
        // int min = abs(num[1] - num[0]);
        // for (int i = 1; i < num.size(); i++)
        // {
        //     if(abs(num[i] - num[i-1]) < min)
        //         min = abs(num[i] - num[i-1]);
        // }
        // return min;

        //双指针做法
        traversal(root);
        return min;
    }
};

---

LeetCode 501 二叉搜索树中的众数 2023.11.14

• 题目链接
• 代码随想录讲解[链接]
  

vector<int> findMode(TreeNode* root) {
    //创建答案数组
    vector<int> result;
    //出现频率最大值，初始化为1
    int max = 1;
    //当前元素出现次数，初始化为1
    int curnum = 1;
    //当前遍历节点
    TreeNode* cur = root;
    //上一个遍历的节点
    TreeNode* pre = NULL;
    //用迭代法遍历，栈存储
    stack<TreeNode*> st;
    //开始后序迭代遍历
    while (cur != NULL || !st.empty())
    {
        //左，先把所有左节点加入栈中
        if(cur != NULL)
        {
            st.push(cur);
            cur = cur->left;
        }
        //中和右
        else
        {
            //对左节点处理
            cur = st.top();
            st.pop();
            //比较与上一个遍历节点的关系，第一次不比较，只赋pre=root
            if(pre != NULL)
            {
                //判断当前节点值与上一节点值是否相等
                if(pre->val == cur->val)
                {
                    //相等则当前值出现次数++
                    curnum++;
                    //如果当前值出现次数大于之前遍历的值最大出现次数，则更新最大频率与其值
                    if(max < curnum)
                    {
                        max = curnum;
                        if(!result.empty())
                            result.erase(result.begin(), result.end());
                        result.push_back(cur->val);
                    }
                    //如果存在同最大频率但值不同情况，则直接把值存入答案数组
                    else if(max == curnum)
                        result.push_back(cur->val); 
                }
                //不相等时，令当前出现次数归1，判断是否与最大出现次数相同，相同则把其值存入答案数组
                else
                {
                    curnum = 1;
                    if(max == curnum)
                        result.push_back(cur->val); 
                }
            }
            //第一次处理节点时，需把该节点存入答案数组中
            else
                result.push_back(cur->val);
            //处理完后跟新上一遍历节点
            pre = cur;
            //遍历右节点
            cur = cur->right;
        }

    }
    return result;
}

---

LeetCode 236 二叉树的最近公共祖先 2023.11.14

• 题目链接
• 代码随想录讲解[链接]
  

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    //题意为二叉树一定存在p、q二值
    //节点为空则返回空
    if(root == NULL)
        return NULL;
    //当当前遍历节点为p或q时，向上返回该节点
    if(root == p || root == q)
        return root;
    //后序遍历，左->右->中
    TreeNode* left = lowestCommonAncestor(root->left, p, q);
    TreeNode* right = lowestCommonAncestor(root->right, p, q);
    //中
    //p、q节点分别在当前根两侧时，那么最近公共祖先即为当前根节点
    if(left && right)
        return root;
    //说明p、q都在左子树上，那么左节点为公共祖先
    else if(left && right == NULL)
        return left;
    //说明p、q都在右子树上，那么右节点为公共祖先
    else if(left == NULL && right)
        return right;
    //没找到则返回空
    else
        return NULL;
}

---