Java實現二叉樹的四種遍歷

package Tree;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Stack;

/**
 * Created by lenovo on 2017/9/6.
 */
public class BinaryTree {
    /*
    * 前序遍歷，遞歸實現
    * */
    public 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 void PreOrder1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        if (root != null) {
            stack.push(root);
        }
        while (!stack.empty()) {
            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);
        }
    }

    /*
    * 中序遍歷，遞歸實現
    * */
    public void InOrder(TreeNode node) {
        if (node != null) {
            InOrder(node.left);
            System.out.print(node.val);
            InOrder(node.right);
        }
    }

    /*
   * 中序遍歷，非遞歸實現
   * 1，首先從根節點出發一路向左，入棧所有的左節點；
   * 2，出棧一個節點，輸出該節點val值，查詢該節點是否存在右節點，
   * 若存在則從該右節點出發一路向左入棧該右節點所在子樹所有的左節點；
   * 3，若不存在右節點，則出棧下一個節點，輸出節點val值，同步驟2操作；
   * 4，直到節點為null，且棧為空。
   * */
    public void InOrder1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        while (root != null || !stack.empty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            if (!stack.empty()) {
                TreeNode node = stack.pop();
                System.out.print(node.val);
                root = node.right;
            }
        }
    }

    /*
    * 后序遍歷，遞歸實現
    * */
    public void PostOrder(TreeNode node) {
        if (node != null) {
            PostOrder(node.left);
            PostOrder(node.right);
            System.out.print(node.val);
        }
    }

    /*
    * 層序遍歷（廣度優先遍歷）
    * */
    public void LayerOrder(TreeNode root) {
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.val);
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
    }
}