二叉树的几种遍历方式

package com.sys.binarytreetest.binary;

import java.security.Principal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;

/**
 * Created by chengjiamei on 2017/8/3.
 */

public class BinaryTree {

    private TreeNode root = null;

    public BinaryTree() {
        root = new TreeNode(1,"A");
        createBinaryTree();
    }

    /**
     * Root 的位置
     * 前序遍历 Root Left Right
     * 中序遍历 Left Root Right
     * 后序遍历 Left Right Root
     * 构建二叉树
     *                      A
     *              B                C
     *      D           E               F
     *  G       H   I       J       K       L
     */
    public void createBinaryTree(){

        TreeNode nodeB = new TreeNode(2,"B");
        TreeNode nodeC = new TreeNode(3,"C");
        TreeNode nodeD = new TreeNode(4,"D");
        TreeNode nodeE = new TreeNode(5,"E");
        TreeNode nodeF = new TreeNode(6,"F");
        TreeNode nodeG = new TreeNode(7,"G");
        TreeNode nodeH = new TreeNode(8,"H");
        TreeNode nodeI = new TreeNode(9,"I");
        TreeNode nodeJ = new TreeNode(10,"J");
        TreeNode nodeK = new TreeNode(11,"K");
        TreeNode nodeL = new TreeNode(12,"L");

        root.leftChild = nodeB;
        root.rightChild = nodeC;

        nodeB.leftChild = nodeD;
        nodeB.rightChild = nodeE;

        nodeC.rightChild = nodeF;

        nodeF.leftChild = nodeK;
        nodeF.rightChild = nodeL;

        nodeD.leftChild = nodeG;
        nodeD.rightChild = nodeH;

        nodeE.leftChild = nodeI;
        nodeE.rightChild = nodeJ;

    }

    public int getHeight() {

        return getHeight(root);
    }

    public int getHeight(TreeNode treeNode) {
        if(treeNode == null)
            return 0;
        int i = getHeight(treeNode.leftChild);
        int j = getHeight(treeNode.rightChild);
        return  i<j?j+1:i+1;
    }

    public int getSize(){
        return getSize(root);
    }

    public int getSize(TreeNode treeNode) {
        if(treeNode == null)
            return 0;
        return 1+getSize(treeNode.leftChild) + getSize(treeNode.rightChild);
    }

    /**
     * 迭代遍历
     * 前序遍历
     * @param treeNode
     */
    private  void preOrder(TreeNode treeNode) {
        if(treeNode == null)
            return;
        System.out.println(treeNode.data);
        preOrder(treeNode.leftChild);
        preOrder(treeNode.rightChild);
    }

    /**
     * 栈式 遍历
     * @param node
     */
    private void nonPreOrder(TreeNode node){
        if(node == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        while (!stack.isEmpty()) {
            TreeNode treeNode = stack.pop();
            System.out.println(treeNode.data);
            if(treeNode.rightChild != null) {
                stack.push(treeNode.rightChild);
            }
            if(treeNode.leftChild != null) {
                stack.push(treeNode.leftChild);
            }

        }
    }

    /**
     * 迭代遍历
     * 中序遍历
     * @param treeNode
     */
    private void midOrder(TreeNode treeNode) {
        if (treeNode == null)
            return;
        midOrder(treeNode.leftChild);
        System.out.println(treeNode.data);
        midOrder(treeNode.rightChild);
    }

    /**
     *  栈式 遍历
     *  中序遍历
     * @param treeNode
     */
    private void nonMidOrder(TreeNode treeNode) {
        if(treeNode == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(treeNode);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            TreeNode nodeLeft = node.leftChild;
            TreeNode nodeRight = node.rightChild;
            if(nodeRight != null) {
                stack.push(nodeRight);
            }
            if(nodeLeft != null || nodeRight != null){
                node.leftChild = null;
                node.rightChild = null;
                stack.push(node);
            }
            if(nodeLeft != null){
                stack.push(nodeLeft);
            }
            if(nodeLeft == null && nodeRight == null){
                System.out.println(node.data);
            }

        }
    }

    /**
     * 迭代遍历
     * 后序遍历
     * @param treeNode
     */
    public void postOrder(TreeNode treeNode) {
        if(treeNode == null)
            return;

        postOrder(treeNode.leftChild);
        postOrder(treeNode.rightChild);
        System.out.println(treeNode.data);
    }

    /**
     *  栈式 遍历
     *  后序遍历
     * @param treeNode
     */
    public void nonPostOrder(TreeNode treeNode) {
        if (treeNode == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(treeNode);

        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            TreeNode nodeLeft = node.leftChild;
            TreeNode nodeRight = node.rightChild;
            if(nodeLeft != null || nodeRight != null){
                node.leftChild = null;
                node.rightChild = null;
                stack.push(node);
            }
            if(nodeRight != null) {
                stack.push(nodeRight);
            }
            if(nodeLeft != null)
                stack.push(nodeLeft);

            if(nodeLeft == null && nodeRight == null) {
                System.out.println(node.data);
            }

        }
    }

    /**
     * 层序遍历
     * @param node
     */
    private void cengxuOrder(TreeNode node){
        if(node == null)
            return;
        int in = 0;
        int out = 0;
        ArrayList<TreeNode> list = new ArrayList<>();
        list.add(in++,node);
        while (in>out) {
            if(list.get(out) != null){
                System.out.println(list.get(out).data);
                if(node.leftChild != null) {
                    list.add(in++, list.get(out).leftChild);
                }
                if( node.rightChild != null){
                    list.add(in++, list.get(out).rightChild);
            }
            }
            out++;
        }

    }

    private List<TreeNode> getList(TreeNode node) {
        ArrayList<TreeNode> list = new ArrayList<>();
        if(node.leftChild != null) {
            list.add(node.leftChild);
        }
        if(node.rightChild != null){
            list.add(node.rightChild);
        }
        return list;
    }

    public class TreeNode {
        private int index;
        private String data;
        private TreeNode leftChild;
        private TreeNode rightChild;

        public TreeNode(int index, String data ) {
            this.index = index;
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }

        public TreeNode getLeftChild() {
            return leftChild;
        }

        public void setLeftChild(TreeNode leftChild) {
            this.leftChild = leftChild;
        }

        public TreeNode getRightChild() {
            return rightChild;
        }

        public void setRightChild(TreeNode rightChild) {
            this.rightChild = rightChild;
        }
    }

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        System.out.print("binary height = "+binaryTree.getHeight());
        System.out.println("binary size = "+binaryTree.getSize());

        //binaryTree.preOrder(binaryTree.root);
        //binaryTree.nonPreOrder(binaryTree.root);
        /*System.out.println();
        binaryTree.midOrder(binaryTree.root);
        System.out.println();
        binaryTree.nonMidOrder(binaryTree.root);
        System.out.println();*/
        /*binaryTree.postOrder(binaryTree.root);
        System.out.println();
        binaryTree.nonPostOrder(binaryTree.root);
        System.out.println();*/

        binaryTree.cengxuOrder(binaryTree.root);

    }
}