BinaryTree traverse

Refer to: https://blog.csdn.net/u011514810/article/details/75907170

package com.multithread;

import sun.reflect.generics.tree.Tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * @author Ruth
 * created on 7/29/2018
 */
public class TraverseTree {

  public static void main(String[] args) {
    TreeNode root = createTree();
    System.out.println("PreOrder : ");
    preOrder(root);
    System.out.println();
    preOrder2(root);
    System.out.println();
    System.out.println("InOrder : ");
    inOrder(root);
    System.out.println();
    inOrder2(root);
    System.out.println();
    System.out.println("PostOrder : ");
    postOrder(root);
    System.out.println();
    postOrder2(root);
    System.out.println();
    System.out.println("LevelOrder : ");
    levelOrder(root);
  }

  public static TreeNode createTree() {
    TreeNode i = new TreeNode("I");
    TreeNode h = new TreeNode("H");
    TreeNode g = new TreeNode("G");
    TreeNode e = new TreeNode("E");
    TreeNode f = new TreeNode("F", h, i);
    TreeNode d = new TreeNode("D", null, g);
    TreeNode c = new TreeNode("C", f, null);
    TreeNode b = new TreeNode("B", d, e);
    TreeNode root = new TreeNode("A", b, c);
    return root;
  }

  //preOrder
  public static void preOrder(TreeNode root) {
    if (root != null) {
      TreeNode.printNode(root);
      preOrder(root.left);
      preOrder(root.right);
    }
  }

  public static void preOrder2(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode p = root;
    while (p != null || !stack.isEmpty()) {
      if (p != null) {
        TreeNode.printNode(p);
        stack.push(p);
        p = p.left;
      } else {
        TreeNode node = stack.pop();
        p = node.right;
      }
    }
  }

  //InOrder
  public static void inOrder(TreeNode root) {
    if (root != null) {
      inOrder(root.left);
      TreeNode.printNode(root);
      inOrder(root.right);
    }
  }

  public static void inOrder2(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode p = root;

    while (!stack.isEmpty() || p != null) {
      if (p != null) {
        stack.push(p);
        p = p.left;
      } else {
        p = stack.pop();
        TreeNode.printNode(p);
        p = p.right;
      }

    }
  }

  //postOrder
  public static void postOrder(TreeNode root) {
    if (root != null) {
      postOrder(root.left);
      postOrder(root.right);
      TreeNode.printNode(root);
    }
  }

  public static void postOrder2(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    Stack<TreeNode> output = new Stack<>();
    TreeNode p = root;
    while (p != null || !stack.isEmpty()) {
      if (p != null) {
        stack.push(p);
        output.push(p);
        p = p.right;
      } else {
        p = stack.pop();
        p = p.left;
      }
    }

    while (!output.isEmpty()) {
      TreeNode.printNode(output.pop());
    }

  }


  //level Order
  public static void levelOrder (TreeNode node) {
    Queue<TreeNode> queue = new LinkedList<>();
    if(node == null) {
      return;
    }

    queue.offer(node);
    while(!queue.isEmpty()) {
      TreeNode element = queue.poll();
      TreeNode.printNode(element);
      if(element.left != null) {
        queue.offer(element.left);
      }

      if(element.right != null) {
        queue.offer(element.right);
      }
    }

  }

}

class TreeNode {
  String value;
  TreeNode left;
  TreeNode right;

  public TreeNode(String value, TreeNode left, TreeNode right) {
    this.value = value;
    this.left = left;
    this.right = right;
  }

  public TreeNode(String value) {
    this(value, null, null);
  }

  public static void printNode(TreeNode node) {
    System.out.print(node.value + " ");
  }

}