BM29 二叉树中和为某一值的路径 (一)

最新推荐文章于 2024-05-20 20:08:58 发布

小火柴66

最新推荐文章于 2024-05-20 20:08:58 发布

阅读量127

点赞数

分类专栏：算法 # 树文章标签： leetcode 算法 bfs 广度优先深度优先

本文链接：https://blog.csdn.net/liulong999/article/details/123835438

版权

算法同时被 2 个专栏收录

53 篇文章 0 订阅

订阅专栏

树

19 篇文章 0 订阅

订阅专栏

在这里插入图片描述
解法一：递归调用，时间复杂度O(N)，空间复杂度O(log(N))，因为遍历了所有的节点，最终将所有的可能返回的结果或运算，所以需要保存每种可能返回的结果，即只需要保存叶子节点的数目，最多只会log(N)

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null && sum == root.val) {
            return true;
        }
        //递归调用
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

第二种方法：非递归，时间复杂度O(N)，空间复杂度O(N),因为需要保存所有的节点，所以空间复杂度O(N)。

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if (root == null) {
            return false;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.left == null && node.right == null && sum == node.val) {
                return true;
            }
            if (node.left != null) {
                node.left.val = node.val + node.left.val;
                stack.push(node.left);
            }
            if (node.right != null) {
                node.right.val = node.val + node.right.val;
                stack.push(node.right);
            }
        }
        return false;
    }

}

第三种方法：dfs，时间复杂度O(N)，空间复杂度O(log(N))

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if (root == null) {
            return false;
        }
        return dfs(root, sum);
    }
    private boolean dfs(TreeNode root, int sum) {
        if (root == null) {
            return false;
        }
        //叶子节点
        if (root.left == null && root.right == null && sum == root.val) {
            return true;
        };
        boolean resultLeft = false;
        boolean resultRight = false;
        if (root.left != null) {
            resultLeft = resultLeft || dfs(root.left, sum - root.val);
        }
        if (root.right != null) {
            resultRight = resultRight || dfs(root.right, sum - root.val);
        }
        return resultLeft || resultRight;
    }
}

第四种方法：bfs，时间复杂度O(N)，空间复杂度O(N),因为需要保存所有的节点，所以空间复杂度O(N)。

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if (root == null) {
            return false;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.left == null && node.right == null && sum == node.val) {
                return true;
            }
            if (node.left != null) {
                node.left.val = node.val + node.left.val;
                queue.add(node.left);
            }
            if (node.right != null) {
                node.right.val = node.val + node.right.val;
                queue.add(node.right);
            }
        }
        return false;
    }

}