[Leetcode 112, Easy] Path sum I

最新推荐文章于 2021-05-26 19:49:01 发布

simplify2012

最新推荐文章于 2021-05-26 19:49:01 发布

阅读量729

点赞数

分类专栏： Leetcode_easy 文章标签： leetcode C++ recersive Binary tree

本文链接：https://blog.csdn.net/u012212811/article/details/14444505

版权

Leetcode_easy 专栏收录该内容

58 篇文章 0 订阅

订阅专栏

Problem:

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

For example:
Given the below binary tree and sum = 22 ,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

Analysis:

The below solutions are recursive. Recursive methods are straightforward.

Of course, we can use non-recursive method to solve them.

1. Below progrem is a typical recursive solution to such problems. The function getPath returns when the recursive pointer reaches a leaf.

2. Notice a boundary case: a tree with only one node, root and its value is equal to the sum.

Solution:

C++:

Recursive solution: (12 ms)

    void CalculatePathSums(TreeNode* local_root, int sum, bool& hasPath)
    {
        if(local_root->left == NULL && local_root->right == NULL) {
            if(sum == local_root->val)
                hasPath = true;
            return;
        } else {
            if(!hasPath && local_root->left != NULL)
                CalculatePathSums(local_root->left, sum - local_root->val, hasPath);
                
            if(!hasPath &&  local_root->right != NULL)
                CalculatePathSums(local_root->right, sum - local_root->val, hasPath);
        }
    }
    
    bool hasPathSum(TreeNode *root, int sum) {
        bool rv = false;
        if(root != NULL)
            CalculatePathSums(root, sum, rv);
        return rv;
    }

Non-recursive solution: (12 ms)

    bool hasPathSum(TreeNode *root, int sum)
    {
        if(root == NULL)
            return false;
        
        bool found = false;
        stack<TreeNode *> node_stack;
        TreeNode *p_cur = root;
        TreeNode *visited = NULL;
        int sum_backup = sum;
        while(p_cur || !node_stack.empty()) {
            if(p_cur) {
                sum -= p_cur->val;
                node_stack.push(p_cur);
                if(p_cur->left == NULL && p_cur->right == NULL && sum == 0) {
                    found = true;
                    break;
                }
                p_cur = p_cur->left;
            } else {
                p_cur = node_stack.top();

                if(p_cur->right == NULL || p_cur->right == visited) {
                    sum += p_cur->val;
                    node_stack.pop();
                    visited = p_cur;
                    p_cur = NULL;
                } else
                    p_cur = p_cur->right;
            }
        }
        
        return found;
    }