树的先序，中序，后序遍历，广度优先遍历，深度优先遍历

树的四种遍历

先序遍历

先访问根节点，再访问左子树，最后访问右子树

比如给定一个二叉树

他的先序遍历结果就为:ABDGHCEF

代码实现

 //先序遍历
    public void beforeOrder(TreeNode treeNode){
        if (treeNode!=null){
            System.out.println(" "+treeNode.getValue()+" ");
            beforeOrder(treeNode.getLeftNode());
            beforeOrder(treeNode.getRightNode());
        }
    }

中序遍历结果就是：GDHBAECF

代码实现

 //中序遍历
    public void inOrder(TreeNode treeNode){
        if (treeNode != null){
            inOrder(treeNode.getLeftNode());
            System.out.println(" "+treeNode.getValue()+" ");
            inOrder(treeNode.getRightNode());
        }
    }

后序遍历结果就是：GHDBEFCA

代码实现

//后序遍历
    public void afterOrder(TreeNode treeNode){
        if(treeNode != null){
            afterOrder(treeNode.getLeftNode());
            afterOrder(treeNode.getRightNode());
            System.out.println(" "+treeNode.getValue()+" ");
        }
    }

广度优先遍历

遍历结果为:ABCDEFGH

代码实现

  //广度优先遍历
    public void levelOrder(TreeNode treeNode){
        LinkedList<TreeNode> list=new LinkedList<>();
        list.add(treeNode);
        TreeNode node;
        while (!list.isEmpty()){
            node=list.pop();
            System.out.println(node.getValue()+" ");
            if(node.getLeftNode()!=null){
                list.add(node.getLeftNode());
            }
            if (node.getRightNode()!=null){
                list.add(node.getRightNode());
            }
        }
    }

深度优先遍历

遍历结果为:ABDGHCEF

代码实现

  //深度优先遍历
    public void depthOrder(TreeNode treeNode){
        Stack<TreeNode> stack=new Stack<>();
        stack.add(treeNode);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            System.out.println(node.getValue());
            if(node.getLeftNode()!=null){
                stack.add(node.getLeftNode());
            }
            if (node.getRightNode()!=null){
                stack.add(node.getRightNode());
            }
        }
    }

遍历的思想是递归

结合两道力扣题来进一步学习

112.给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

算法思想，递归，找出最小问题，即当前节点的值是否是目标值

public boolean hashPathSum(TreeNode root,int targetSum){
if(root==null) return flase;
 if(root.left==null&&root.right==null){
     return root.val==targetSum
 }
  return hashPathSum(root.left,targetSum-root.val) || hashPathSum(root.right,targetSum-root.val);
}

113.给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

算法思想:深度优先遍历，递归，找出最小问题，返回

class Solution{
	List<List<Integer>> list = new Lsit<>();
    Deque<Integer> deque=new Deque<>();
 	public List<List<Integer>> pathSum(TreeNode root, int targetSum){
        dfs(root,targetSum);
        return list;

}
	public void dfs(TreeNode node,targetSum){
        if(node==null) return;
        deque.offerLast(node.val);
        targetSum=targetSum-node.val;
        if(node.left==null && node.right==null && targetSum==0){
		list.add(new LinkedList<Integer>(deque));
        }
        dfs(node.left,targetSum-node.val);
        dfs(node.right,targetSum-node.val);
        deque.pollLast();
    } 
}