力扣98. 验证二叉搜索树- java五种解法

题目描述

给定一个二叉树，它的每个节点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 1->2->3 代表数字 123。

计算从根到叶子节点生成的所有数字之和。

说明: 叶子节点是指没有子节点的节点。

示例 1:

输入: [1,2,3]
1
/
2 3
输出: 25
解释:
从根到叶子节点路径 1->2 代表数字 12.
从根到叶子节点路径 1->3 代表数字 13.
因此，数字总和 = 12 + 13 = 25.
示例 2:

输入: [4,9,0,5,1]
4
/
9 0
/
5 1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.

解决思路及复杂度分析

本题是一道经典的二叉树遍历问题，根据题目中所给的含义求解即可。可用递归/栈/队列等方式来解决，以下分别对各个解法进行分析：

解法1：深度优先搜索（递归）
对二叉树进行深度优先搜索，使用递归的方式即可。对于每个节点，计算从父节点传递下来的数字，然后依次访问左右子节点。如果访问到叶节点，则将计算结果加入到最终结果中。时间复杂度为 O(n)，其中 n 为节点数。

Java 代码：

class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return dfs(root, 0);
    }

    private int dfs(TreeNode node, int prevSum) {
        if (node == null) {
            return 0;
        }
        int sum = prevSum * 10 + node.val;
        if (node.left == null && node.right == null) {
            return sum;
        } else {
            return dfs(node.left, sum) + dfs(node.right, sum);
        }
    }
}

解法2：广度优先搜索（迭代）
对二叉树进行广度优先搜索，使用迭代的方式实现。使用两个队列，一个队列保存访问节点，另一个队列保存路径数值。对于每个节点，将其数值乘以 10 并加上父节点传递下来的数值，然后将左右子节点加入队列，重复以上过程。如果访问到叶节点，则将路径数值加入到最终结果中。时间复杂度为 O(n)，其中 n 为节点数。

Java 代码：

class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        Queue<Integer> numQueue = new LinkedList<>();
        nodeQueue.offer(root);
        numQueue.offer(root.val);
        int sum = 0;
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll();
            int num = numQueue.poll();
            if (node.left == null && node.right == null) {
                sum += num;
            } else {
                if (node.left != null) {
                    nodeQueue.offer(node.left);
                    numQueue.offer(num * 10 + node.left.val);
                }
                if (node.right != null) {
                    nodeQueue.offer(node.right);
                    numQueue.offer(num * 10 + node.right.val);
                }
            }
        }
        return sum;
    }
}

解法3：深度优先搜索（栈）

对二叉树进行深度优先搜索，使用栈的方式实现。使用两个栈，一个栈保存访问节点，另一个栈保存路径数值。对于每个节点，将其数值乘以 10 并加上父节点传递下来的数值，然后将左右子节点加入栈，重复以上过程。如果访问到叶节点，则将路径数值加入到最终结果中。时间复杂度为 O(n)，其中 n 为节点数。

Java 代码：

class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> numStack = new Stack<>();
        stack.push(root);
        numStack.push(root.val);
        int sum = 0;
        while (!stack.empty()) {
            TreeNode node = stack.pop();
            int num = numStack.pop();
            if (node.left == null && node.right == null) {
                sum += num;
            } else {
                if (node.right != null) {
                    stack.push(node.right);
                    numStack.push(num * 10 + node.right.val);
                }
                if (node.left != null) {
                    stack.push(node.left);
                    numStack.push(num * 10 + node.left.val);
                }
            }
        }
        return sum;
    }
}

解法4：深度优先搜索（栈，非递归）
对二叉树进行深度优先搜索，使用栈的方式实现。将每个偏左的节点作为根节点进行搜索，同时需要将其值累加到右节点，最后将所有叶节点的值累加即可。时间复杂度为 O(n)，其中 n 为节点数。

Java 代码：

class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int sum = 0;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()) {
            TreeNode node = stack.pop();
            if (node.left == null && node.right == null) {
                sum += node.val;
            }
            if (node.right != null) {
                node.right.val += node.val * 10;
                stack.push(node.right);
            }
            if (node.left != null) {
                node.left.val += node.val * 10;
                stack.push(node.left);
            }
        }
        return sum;
    }
}

解法5：深度优先搜索（递归，中序遍历）
对二叉树进行深度优先搜索，使用递归的方式实现。使用中序遍历，对于每个节点，将其值累加到 num 中，并往下遍历。如果访问到叶节点，则将路径数值加入到最终结果中。

Java 代码：

class Solution {
    private int sum = 0;

    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        inorder(root, 0);
        return sum;
    }

    private void inorder(TreeNode node, int num) {
        if (node.left == null && node.right == null) {
            sum += num * 10 + node.val;
            return;
        }
        num = num * 10 + node.val;
        if (node.left != null) {
            inorder(node.left, num);
        }
        if (node.right != null) {
            inorder(node.right, num);
        }
    }
}