leetcode112 Path Sum

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.

下面程序中包含树的非递归遍历与PathSum的解法。PathSum采用了非递归遍历的思想

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Solution {

	/*
	 * 二叉树的非递归后序遍历，采用Java实现
	 * 因为下面程序采用了该方法
	 */
	public static void postOrder(TreeNode root){
		Stack<TreeNode> stack = new Stack<TreeNode>();
		TreeNode p = null;
		TreeNode b = root;
		int flag;
		do{
			while(b!=null){
				stack.push(b);
				b = b.left;
			}
			p = null;
			flag = 1;
			while(!stack.isEmpty() && flag==1){
				b = stack.peek();
				if(b.right==p){
					System.out.println(b.val);
					stack.pop();
					p = b;
				}else{
					b = b.right;
					flag = 0;
				}
			}
		}while(!stack.isEmpty());
		
	}
	/*
	 * 解答Path Sum问题的源程序，采用了树的非递归后序遍历的思想
	 */
	public boolean hasPathSum(TreeNode root, int sum) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode q = null;
        TreeNode b = root;
        int flag;
        boolean flagAll = false;
        do{
        	while(b!=null){
        		stack.push(b);
        		b = b.left;
        	}
        	q = null;
        	flag = 1;
        	
        	while(!stack.isEmpty() && flag==1){
        		b = stack.peek();
        		if(b.right==q){
        			if(b.left==null && b.right==null){
        				List<TreeNode> pathList = new ArrayList<TreeNode>();
        				while(!stack.isEmpty()){
        					TreeNode x = stack.pop();
        					pathList.add(x);
        				}
        				int sum1 = 0;
        				for(int i = 0;i<pathList.size();i++){
        					sum1+=pathList.get(i).val;
        				}
        				if(sum1==sum){
        					flagAll = true;
        					break;
        				}
        					//return true;
        				for(int i = pathList.size()-1;i>=0;i--){
        					stack.push(pathList.get(i));
        				}
        			}
        			stack.pop();
        			q = b;
        		}else{
        			b = b.right;
        			flag = 0;
        		}
        	}
        }while(!stack.isEmpty());
        return flagAll;
    }
	public static void main(String[] args) {
		TreeNode root = new TreeNode(5);
		TreeNode l1 = new TreeNode(4);
		TreeNode l2 = new TreeNode(8);
		root.left = l1;
		root.right = l2;
		TreeNode l3 = new TreeNode(11);
		l1.left = l3;
		TreeNode l4 = new TreeNode(13);
		l2.left = l4;
		TreeNode l5 = new TreeNode(4);
		l2.right = l5;
		postOrder(root);
		System.out.println(new Solution().hasPathSum(root, 17));
	}

}

class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;

	TreeNode(int x) {
		val = x;
	}
}