112.Path Sum

题目链接：https://leetcode.com/problems/path-sum/description/

题目大意：给出一个二叉树和一个数字，求出是否有从根节点到叶节点的路径上的数之和等于这个数字，如果有返回true，否则返回false。

法一：利用先序遍历的思想，先对结点值进行加和然后再递归计算左子树和右子树，注意一个细节是结点值有可能为负值，所以在初始化的时候以及何时进行判断应特别注意，代码如下（耗时1ms）：

    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null) {
            return false;
        }
        return dfs(root, sum, 0, false);
    }
    public static boolean dfs(TreeNode root, int sum, int cnt, boolean flag) {
        if(flag == true || root == null) {
            return flag;
        }
        cnt += root.val;
        if(cnt == sum && root.left == null && root.right == null) {
            //这个判断不能放在cnt加和之前
            //如果放在cnt之前，判断的是直到root的上一个结点的路径和情况，不是当前root结点的情况
            flag = true;
            return flag;
        }
        flag = dfs(root.left, sum, cnt, flag);
        flag = dfs(root.right, sum, cnt, flag);
        return flag;
    }

法二（借鉴）：后序非递归遍历，参见145题解，代码如下（耗时7ms）：

    public boolean hasPathSum(TreeNode root, int sum) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(root == null) {
            return false;
        }
        stack.push(root);
        TreeNode pre = null, cur = root.left;
        int cnt = root.val;
        while(!stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                cnt += cur.val;
                cur = cur.left;
            }
            cur = stack.peek();
            if(cur.left == null && cur.right == null && cnt == sum) {
                return true;
            }
            if(cur.right != null && pre != cur.right) {
                cur = cur.right;
            }
            else {
                cnt -= cur.val;
                stack.pop();
                pre = cur;
                cur = null;
            }
        }
        return false;
    }

法三（借鉴）：后序非递归遍历，参见145题解，代码如下（耗时9ms）：

public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null) {
            return false;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Integer> stackFlag = new Stack<Integer>();
        stack.push(root);
        stackFlag.push(0);
        TreeNode tmp = root.left;
        int cnt = root.val;
        while(!stack.isEmpty()) {
            while(tmp != null) {
                cnt += tmp.val;
                stack.push(tmp);
                stackFlag.push(0);
                tmp = tmp.left;
            }
            if(!stack.isEmpty()) {
                if(stackFlag.peek() == 0) {
                    tmp = stack.peek().right;
                    stackFlag.pop();
                    stackFlag.push(1);
                }
                else {
                    if(cnt == sum && stack.peek().left == null && stack.peek().right == null) {
                        return true;
                    }
                    cnt -= stack.pop().val;
                    stackFlag.pop();
                }
            }
        }
        return false;
    }

还是没明白为啥非递归比递归要慢这么多？难道是非递归写错了？