java 创建二叉树 前序、中序、后续 递归遍历树 和 非递归遍历，递归求树高，递归求树节点数

package treeTest;

import java.util.Stack;

public class BinaryTree2 {

public class TreeNode{
private int index;
private String date;
private TreeNode leftChild;
private TreeNode rightCHild;

public int getIndex() {
return index;
}

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

public String getDate() {
return date;
}

public void setDate(String date) {
this.date = date;
}

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

private TreeNode root = null;

public BinaryTree2(){
root = new TreeNode(1,"A");
}
/**
* 创建树
* */
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 nodeH = new TreeNode(7,"H");
TreeNode nodeI = new TreeNode(8,"I");
root.leftChild = nodeB;
root.rightCHild = nodeC;
nodeB.leftChild = nodeD;
nodeB.rightCHild = nodeE;
nodeC.rightCHild = nodeF;
nodeE.leftChild = nodeH;
nodeE.rightCHild = nodeI;
}

/**
* 获得树的高度
* */
public int getHeight(){
return getHeight(root);
}

private int getHeight(TreeNode root) {
if(root == null){
return 0;
}
int i = getHeight(root.leftChild);
int j = getHeight(root.rightCHild);
return i<j ? j+1 :i+1;
}

/**
* 获得树的节点数
* */
public int getNodeSize(){
return getNodeSize(root);
}
private int getNodeSize(TreeNode root) {
if(root == null){
return 0;
}
return 1 + getNodeSize(root.leftChild) + getNodeSize(root.rightCHild);
}

/**
* 使用递归   前序遍历
* */
public void preOrder(TreeNode node){
if(node == null){
return;
}
System.out.println(node.getDate());
preOrder(node.leftChild);
preOrder(node.rightCHild);
}

/**
* 使用递归  中序遍历
* */
public void midOrder(TreeNode node){
if(node == null){
return;
}
midOrder(node.leftChild);
System.out.println(node.getDate());
midOrder(node.rightCHild);
}

/**
* 使用递归 后续遍历
* */
public void postOrder(TreeNode node){
if(node == null){
return;
}
postOrder(node.leftChild);
postOrder(node.rightCHild);
System.out.println(node.getDate());
}

/**
* 非递归 前序遍历
* */
public void nonRecOrder(TreeNode node){
if(node == null){
return;
}
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(node);
while(!stack.isEmpty()){
TreeNode n = stack.pop();
System.out.println(n.getDate());
if(n.rightCHild != null){
stack.push(n.rightCHild);
}

4000
if(n.leftChild != null){
stack.push(n.leftChild);
}
}
}

/**
* 非递归 中序遍历
* */
public void nonMidOrder(TreeNode node){
if(node == null){
return;
}
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(node);
TreeNode n = stack.peek();
while(!stack.isEmpty()){
if(n.leftChild != null){
stack.push(n.leftChild);
n = n.leftChild;
continue;
}
n = stack.pop();
System.out.println(n.getDate());
if(n.rightCHild != null){
stack.push(n.rightCHild);
n= n.rightCHild;
}
}
}

/**
* 非递归  后续遍历
* */
public void nonPostOrder(TreeNode node){
if(node == null){
return;
}
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(node);
while(!stack.isEmpty()){
TreeNode n = stack.peek();
if(n.leftChild == null && n.rightCHild == null){
n = stack.pop();
System.out.println(n.getDate());
}else{
if(n.rightCHild != null){
stack.push(n.rightCHild);
n.rightCHild = null;
}
if(n.leftChild !=null){
stack.push(n.leftChild);
n.leftChild = null;
}
}
}
}

public static void main(String []args){
BinaryTree2 binaryTree = new BinaryTree2();
binaryTree.createBinaryTree();
//		int height = binaryTree.getHeight();
//		System.out.println("TreeHeight:" + height);
//		int nodeSize = binaryTree.getNodeSize();
//		System.out.println("TreeNode:" + nodeSize);
//		binaryTree.preOrder(binaryTree.root);
//		binaryTree.midOrder(binaryTree.root);
//		binaryTree.postOrder(binaryTree.root);
//		binaryTree.nonRecOrder(binaryTree.root);
//		binaryTree.nonMidOrder(binaryTree.root);
binaryTree.nonPostOrder(binaryTree.root);

}
}