二叉树的遍历（包含递归非递归）

public static void PreOrder(TreeNode node) {
              if (node != null) {
                      System.out.print(node.val);
                      PreOrder(node.left);
                      PreOrder(node.right);
                  }
         }

 /*
   * 前序遍历，非递归实现
   * 1，先入栈根节点，输出根节点val值，再先后入栈其右节点、左结点；
   * 2，出栈左节点，输出其val值，再入栈该左节点的右节点、左节点；直到遍历完该左节点所在子树。
   * 3，再出栈右节点，输出其val值，再入栈该右节点的右节点、左节点；直到遍历完该右节点所在子树。
   *
 */
 public static void preNoOrder(TreeNode root){
     Stack<TreeNode> stack = new Stack<>();
     if (root!=null){
         stack.push(root);
     }
     while(stack!=null&&stack.size()!=0){
         TreeNode node= stack.pop();
         System.out.print(node.val);
         if (node.right!=null){
             stack.push(node.right);
         }
         if (node.left!=null){
             stack.push(node.left);
         }
     }
 }

 /*
* 中序遍历，非递归实现
* 1，首先从根节点出发一路向左，入栈所有的左节点；
* 2，出栈一个节点，输出该节点val值，查询该节点是否存在右节点，
* 若存在则从该右节点出发一路向左入栈该右节点所在子树所有的左节点；
* 3，若不存在右节点，则出栈下一个节点，输出节点val值，同步骤2操作；
* 4，直到节点为null，且栈为空。
* */
 public static void InNoOrder(TreeNode root){
     Stack<TreeNode> stack = new Stack<>();
     while(root!=null||stack.size()>0){
         while (root!=null){
             stack.push(root);
             root = root.left;
         }
         if (stack.size()>0){
             TreeNode node = stack.pop();
             System.out.print(node.val);
             root = node.right;
         }
     }
 }
 /*
 递归中序
  */
 public static void InOrder(TreeNode node) {
     if (node != null) {
         InOrder(node.left);
         System.out.print(node.val);
         InOrder(node.right);

     }
 }
 /*
 非递归后序，一个是排好序的栈，另一个是用于判断的栈
 1.根节点押进去
 2.查询是否有右节点，有的话押进去，没有去查左节点
 3.将左节点押进去
 4.将排好序的输出
  */
 public static void PostNoOrder(TreeNode root) {   //后序遍历
     Stack<TreeNode> stack = new Stack<TreeNode>();
     Stack<TreeNode> output = new Stack<TreeNode>();//构造一个中间栈来存储逆后序遍历的结果
     TreeNode node = root;
     while (node != null || stack.size() > 0) {
         if (node != null) {
             output.push(node);
             stack.push(node);
             node = node.right;
         } else {
             node = stack.pop();
             node = node.left;
         }
     }
     while (output.size() > 0) {
         TreeNode node1 = output.pop();
         System.out.print(node1.val);
     }
 }
 /*
 后序递归遍历
  */

 public static void PostOrder(TreeNode node) {
     if (node != null) {
         PostOrder(node.left);
         PostOrder(node.right);
         System.out.print(node.val);
     }
 }
//测试方法
 public static void main(String[] args) {
     TreeNode root = new TreeNode('A');
     root.left = new TreeNode('B');
     root.right = new TreeNode('C');
     root.left.left = new TreeNode('D');
     root.left.right = new TreeNode('E');
     root.right.left = new TreeNode('F');
     PreOrder(root);
     System.out.println();
     preNoOrder(root);
     System.out.println();
     InNoOrder(root);
     System.out.println();
     InOrder(root);
     System.out.println();
     PostNoOrder(root);
     System.out.println();
     PostOrder(root);

 }
备注：
定义的二叉树

public class TreeNode {
    public char val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(char val){
        this.val = val;
    }
}