第4周 数据结构-树

• 统计路径和等于一个数的路径数量 437. Path Sum III(Medium)
• 子树 572. Subtree of Another Tree (Easy)
• 树的对称 101. Symmetric Tree(Easy)
• 最小路径 111. Minimum Depth of Binary Tree (Easy)
• 404. Sum of Left Leaves(Easy)

统计路径和等于一个数的路径数量

class Solution {
public:
    int SumCount(TreeNode* root, int targetSum, bool takeroot){
        int ans = 0;
        if(root->val == targetSum)
            ans += 1;
        if(takeroot){ // 要拿root就要一直拿
            ans += root->left != NULL ? SumCount(root->left, targetSum - root->val, true) : 0;
            ans += root->right != NULL ? SumCount(root->right, targetSum - root->val, true) : 0;
        }
        else{
            ans += root->left != NULL ? SumCount(root->left, targetSum, false) : 0;
            ans += root->right != NULL ? SumCount(root->right, targetSum, false) : 0;
            ans += root->left != NULL ? SumCount(root->left, targetSum - root->val, true) : 0;
            ans += root->right != NULL ? SumCount(root->right, targetSum - root->val, true) : 0;
        }
        return ans;
    }
    int pathSum_Recursive(TreeNode* root, int targetSum) {
        /*
        思路：递归求子树sum为targetSum的路径条数，注意在把root的值作为targetSum的一部分时在处理该root的子节点时也全都要被作为targetSum的一部分，否则得到的就不是连续的path
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return 0;
        return SumCount(root, targetSum, false);

    int ans = 0;

    void helper(TreeNode* root, vector<int>& path, int target){
        if(root == NULL)
            return ;

        path.push_back(root->val);

        int sum = 0;
        for(int i = path.size()-1;i >= 0; i--){
            sum += path[i];
            if(sum == target)
                ans += 1;
        }

        helper(root->left, path, target);
        helper(root->right, path, target);

        path.pop_back();
    }
    int pathSum(TreeNode* root, int targetSum){
        /*
        思路：遍历树的过程中不断把值push到vector中，push完一个检查下有没有sum为targetSum的子数组，注意这里的子数组限制为从最后一个节点开始的子数组，对于每一个存在于树中的和为targetSum的oath，总能够在push最后一个节点时发现它，并且只会被计数一次。这种方法和递归式思想不同，这里的找path可以认为是从下到上，递归是从上到下。
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return 0;
        vector<int> path;
        ans = 0;
        helper(root, path, targetSum);
        return ans;
    }

};

子树

class Solution {
public:
    bool match(TreeNode* root, TreeNode* subRoot){
        if(root == NULL && subRoot == NULL)
            return true;
        if(root == NULL || subRoot == NULL)
            return false;
        if(root->val == subRoot->val)
            return match(root->left, subRoot->left) && match(root->right, subRoot->right);
        else
            return false;
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        /*
        思路：先判断树和子树是否相同，不同再在树的左右子树中寻找是否有和子树相同的子结构
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return false;
        if(match(root, subRoot))
            return true;
        return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
    }
};

树的对称

class Solution {
public:
    bool isSymmetricPair(TreeNode* node1, TreeNode* node2){
        if(node1 == NULL && node2 == NULL)
            return true;
        if(node1 == NULL || node2 == NULL)
            return false;

        return node1->val == node2->val && isSymmetricPair(node1->left, node2->right) && isSymmetricPair(node1->right, node2->left);
    }

    bool isSymmetric(TreeNode* root) {
        /*
        思路：如果一棵树为对称树，则根节点的左右子树互为对称树
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return true;
        return isSymmetricPair(root->left, root->right);
    }
};

最小路径

class Solution {
public:
    int minDepth(TreeNode* root) {
        /*
        思路：广度优先搜索，搜到的第一个叶节点的深度就是最小深度
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return 0;
        queue<pair<TreeNode*, int> > q;
        q.push(make_pair(root, 1));
        while(!q.empty()){
            pair u = q.front();
            q.pop();

            TreeNode* node = u.first;
            int depth = u.second;

            if(node->left == NULL && node->right == NULL)
                return depth;
            else{
                if(node->left != NULL)
                    q.push(make_pair(node->left, depth+1));
                if(node->right != NULL)
                    q.push(make_pair(node->right, depth+1));
            }
        }
        return 0;
    }
};

统计左叶子节点的和

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        /*
        思路：遍历到左叶节点则返回值，否则求左右子树左叶节点值的和，注意这里递归遍历时必须传入一个变量表明是否为左叶节点，否则遍历到叶节点后无法判断是否为左叶节点
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        return sumHelper(root, false);
    }
    int sumHelper(TreeNode* node, bool isLeft){
        if(node == NULL)
            return 0;
        if(node->left == NULL && node->right == NULL && isLeft)
            return node->val;
        return sumHelper(node->left, true) + sumHelper(node->right, false);
    }
};