leetcode—树(easy) 3/4

1.二叉搜索树的最近公共祖先

给定一个二叉搜索树，找到该树中两个指定节点的最近公共祖先。

思路：根据二叉搜索树左小右大的特点，比较根节点的值在两个指定值的哪一侧

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* temp = root;
        while(temp)
        {
            if(p -> val < temp -> val && q -> val < temp -> val)
            {
                temp = temp -> left;
            }
            else if(p -> val > temp -> val && q -> val > temp -> val)
            {
                temp = temp -> right;
            }
            else
            {
                return temp;
            }
        }
        return nullptr;
    }

2.二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

思路：DFS，另外传递一个作为字符串的参数

class Solution {
private:
    vector<string> l;
public:
    void DFS(TreeNode* root, string s)
    {
        if(root -> left == nullptr && root -> right == nullptr)
        {
            l.push_back(s);
        }
        else
        {
            if(root -> left)
            {
                DFS(root -> left, s + "->" + to_string(root -> left -> val));
            }
            if(root -> right != nullptr)
            {
                DFS(root -> right, s + "->" + to_string(root -> right -> val));
            }
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        if(root == nullptr)
        {
            return l;
        }
        DFS(root, to_string(root -> val));
        return l;
    }
};

3.左叶子之和

计算给定二叉树的所有左叶子之和

class Solution {
private:
    int sum = 0;
public:
    void left_search(TreeNode* root)
    {
        TreeNode* p = root;
        if(p == nullptr)
        {
            return;
        }
        
        if(p -> left != nullptr && p -> left -> left == nullptr && p -> left -> right == nullptr)
        {
            sum += p -> left -> val;
        }
        left_search(p -> left);
        left_search(p -> right);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        if(root == nullptr)
        {
            return 0;
        }
        left_search(root);
        return sum;
    }
};

4.路径总和

给定一个二叉树，每个节点都存放着一个整数值。找出路径和等于给定数值的路径总数。路径不需要从根节点开始，也不需要在叶子节点结束，但路径方向必须是向下的。

思路：先序递归遍历每个节点，再以每个节点作为起点递归寻找满足要求的路径。

int pathSum(TreeNode* root, int sum) {
        if(root == nullptr)
        {
            return 0;
        }
        return root_pathSum(root, sum) + pathSum(root -> left, sum) + pathSum(root -> right, sum);
    }
    int root_pathSum(TreeNode* root, int sum)
    {
        if(root == nullptr)
        {
            return 0;
        }
        else if(root -> val == sum)
        {
            return 1 + root_pathSum(root -> left, 0) + root_pathSum(root -> right, 0);
        }
        else
        {
            return root_pathSum(root -> left, sum - root -> val) 
                 + root_pathSum(root -> right, sum - root -> val);
        }
    }

5.二叉搜索树中的众数

给定一个有相同值的BST，找到BST中的所有众数。

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

思路：由于是二叉搜索树，所以考虑用中序遍历后利用哈希表求众数

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

给定一个二叉搜索树，把它转换为累加树，使得每个节点的值是原来的节点值加上大于它的节点值之和。

思路：由于是二叉搜索树，左面的节点要比右面的节点小，可以按照右—根—左的顺序遍历二叉树。

class Solution {
private:
    int preNum = 0;
public:
    void RDL(TreeNode* root)
    {
        TreeNode* p = root;
        if(p == nullptr)
        {
            return;
        }
        RDL(root -> right);
        root -> val += preNum;
        preNum = root -> val;
        RDL(root -> left);
    }
    TreeNode* convertBST(TreeNode* root) {
        if(root == nullptr)
        {
            return root;
        }
        RDL(root);
        return root;
    }
};