二叉树的几种遍历方式

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);

}
}