代码随想录算法训练营-二叉树遍历中的双指针|530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、538.把二叉搜索树转换为累加树

目录

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

501.二叉搜索树中的众数

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

---

双指针中，一个pre指针，一个cur指针，cur指针随着树的遍历不断更新，pre指针按照一定规则更新，处理步骤如下：

初始化pre指针

处理当前树节点cur

更新pre指针

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

力扣题目链接(opens new window)

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

提示：树中至少有 2 个节点。

 思路：二叉搜索树是有序的，可以将其中序遍历，得到结果数组，其结果数组是递增的，那么最小绝对值差肯定是相邻节点之差，遍历的时候维护更新一个最小值即可；

如果要求不使用额外空间，那么就需要一个pre指针记录上一个节点值，遍历的时候和当前节点值做差，然后维护一个最小值

class Solution {
private:
int result = INT_MAX;
TreeNode* pre = NULL;//初始化pre
void traversal(TreeNode* cur) {
    if (cur == NULL) return;
    traversal(cur->left);   // 左
    if (pre != NULL){       // 中,处理当前节点
        result = min(result, cur->val - pre->val);
    }
    pre = cur; // 更新pre
    traversal(cur->right);  // 右
}
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

501.二叉搜索树中的众数

力扣题目链接(opens new window)

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

• 结点左子树中所含结点的值小于等于当前结点的值
• 结点右子树中所含结点的值大于等于当前结点的值
• 左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

思路：二叉搜索树是有序的，因此相同值的节点应该出现在临近节点上，用一个pre指针记录前一个遍历过的节点，用一个count记录出现次数，pre=cur时，count++；用一个vector数组result记录结果，如果count>maxcount，清空result数组，再记录众数，如果count=maxcount,直接记录众数。

class Solution {
private:
    int maxCount = 0; // 最大频率
    int count = 0; // 统计频率
    TreeNode* pre = NULL;//初始化pre
    vector<int> result;
    void searchBST(TreeNode* cur) {
        if (cur == NULL) return ;

        searchBST(cur->left);       // 左
                                    // 中
        if (pre == NULL) { // 第一个节点
            count = 1;
        } else if (pre->val == cur->val) { // 与前一个节点数值相同
            count++;
        } else { // 与前一个节点数值不同
            count = 1;
        }
        pre = cur; // 更新上一个节点

        if (count == maxCount) { // 如果和最大值相同，放进result中
            result.push_back(cur->val);
        }

        if (count > maxCount) { // 如果计数大于最大值频率
            maxCount = count;   // 更新最大频率
            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
            result.push_back(cur->val);
        }

        searchBST(cur->right);      // 右
        return ;
    }

public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        pre = NULL; // 记录前一个节点
        result.clear();

        searchBST(root);
        return result;
    }
};

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

力扣题目链接(opens new window)

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键 小于 节点键的节点。 节点的右子树仅包含键 大于 节点键的节点。 左右子树也必须是二叉搜索树。

示例 1：

• 输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
• 输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

示例 2：

• 输入：root = [0,null,1]
• 输出：[1,null,1]

示例 3：

• 输入：root = [1,0,2]
• 输出：[3,3,2]

示例 4：

• 输入：root = [3,2,4,1]
• 输出：[7,9,4,10]

思路：换一个角度来看，这就是一个有序数组[2, 5, 13]，求从后到前的累加数组，也就是[20, 18, 13]，是不是感觉这就简单了。从树中可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了。这里就需要一个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:
    int pre=0;
    void traversal(TreeNode* cur){
        if(cur==nullptr)return;
        traversal(cur->right);//右
        cur->val+=pre;//中
        pre=cur->val;//更新pre
        traversal(cur->left);//左
        return ;
    }
    TreeNode* convertBST(TreeNode* root) {
        traversal(root);
        return root;
    }
};

参考：代码随想录