【LeetCode】Path Sum ---------LeetCode java 小结

Path Sum 

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.

思路：深度遍历（后续遍历）。每当访问到叶子节点时，计算栈内的元素，也就是从根节点到叶子节点的路径。

public boolean hasPathSum(TreeNode root, int sum) {

       Stack<TreeNode> stack = new Stack<>();

        int total = 0;

        if (root == null)

            return false;

        TreeNode qNode=root;

        while (root != null) {

            while (root.left != null) {

                stack.push(root);

                total += root.val;

                root = root.left;

            }

            while (root != null && (root.right == null || root.right == qNode)) {

                if(root.right==null&&root.left==null){//访问到叶子节点

                    if(total+root.val==sum){

                        return true;

                    }

                }

                qNode = root;// 记录上一个已输出节点

                if (stack.empty())

                    return false;

                root = stack.pop();

                total-=root.val;

            }

            stack.push(root);

            total+=root.val;

            root = root.right;

        }

        return false; 

    }

这个题目中，叶子结点不是非常清楚，考虑这种情况

　　　　　　　　1

　　　　　　　/　

　　　　　　2　　

　结果为1，应该是正确的，存在path。

 

在此回顾一下二叉树的遍历（参考http://maizi2011.iteye.com/blog/938749）

　　/** 递归实现前序遍历 */   

　　protected static void preorder(BTNode p) {   

　　　　if (p != null) {   

　　　　　　visit(p);   

　　　　　　preorder(p.getLeft());   

　　　　　　preorder(p.getRight());   

　　　　}   

　　}   

　　/** 递归实现中序遍历 */   

　　protected static void inorder(BTNode p) {   

　　　　if (p != null) {   

　　　　　　inorder(p.getLeft());   

　　　　　　visit(p);   

　　　　　　inorder(p.getRight());   

　　　　}   

　　}   

　　/** 递归实现后序遍历 */   

　　protected static void postorder(BTNode p) {   

　　　　if (p != null) {   

　　　　　　postorder(p.getLeft());   

　　　　　　postorder(p.getRight());   

　　　　　　visit(p);   

　　　　}   

　　}   

　　/** 非递归实现前序遍历 */   

　　protected static void iterativePreorder(BTNode p) {   

　　　　Stack<BTNode> stack = new Stack<BTNode>();   

　　　　if (p != null) {   

　　　　　　stack.push(p);   

　　　　　　while (!stack.empty()) {   

　　　　　　　　p = stack.pop();   

　　　　　　　　visit(p);   

　　　　　　　　if (p.getRight() != null)   

　　　　　　　　　　stack.push(p.getRight());   

　　　　　　　　if (p.getLeft() != null)   

　　　　　　　　　　stack.push(p.getLeft());   

　　　　　　}   

　　　　}   

　　}   

　　/** 非递归实现后序遍历 */   

　　protected static void iterativePostorder(BTNode p) {   

　　　　BTNode q = p;   

　　　　Stack<BTNode> stack = new Stack<BTNode>();   

　　　　while (p != null) {   

　　　　　　// 左子树入栈   

　　　　　　for (; p.getLeft() != null; p = p.getLeft())   

　　　　　　　　stack.push(p);   

　　　　　　// 当前节点无右子或右子已经输出   

　　　　　　while (p != null && (p.getRight() == null || p.getRight() == q)) {   

　　　　　　　　visit(p);   

　　　　　　　　q = p;// 记录上一个已输出节点   

　　　　　　　　if (stack.empty())   

　　　　　　　　　　return;   

　　　　　　　　p = stack.pop();   

　　　　　　}   

　　　　　　// 处理右子   

　　　　　　stack.push(p);   

　　　　　　p = p.getRight();   

　　　　}   

　　}   

　　/** 非递归实现中序遍历 */   

　　protected static void iterativeInorder(BTNode p) {   

　　　　Stack<BTNode> stack = new Stack<BTNode>();   

　　　　while (p != null) {   

　　　　　　while (p != null) {   

　　　　　　　　if (p.getRight() != null)   

　　　　　　　　　　stack.push(p.getRight());// 当前节点右子入栈   

　　　　　　　　stack.push(p);// 当前节点入栈   

　　　　　　　　p = p.getLeft();   

　　　　　　}   

　　　　　　p = stack.pop();   

　　　　　　while (!stack.empty() && p.getRight() == null) {   

　　　　　　　　visit(p);   

　　　　　　　　p = stack.pop();   

　　　　　　}   

　　　　　　visit(p);   

　　　　　　if (!stack.empty())   

　　　　　　　　p = stack.pop();   

　　　　　　else   

　　　　　　　　p = null;   

　　　　}   

　　}