sfsf

package com.test;

import java.awt.Robot;
import java.lang.Thread.State;
import java.util.Stack;

public class BinaryTree {
private TreeNode  root = null;
	
	public BinaryTree(){
		root = new TreeNode(1, "A");
	}
	
	/**
	 * 构建二叉树
	 *         A
	 *     B       C
	 * D      E        F
	 *                    G
	 */
	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");
		root.leftChild = nodeB;
		root.rightChild = nodeC;
		nodeB.leftChild = nodeD;
		nodeB.rightChild = nodeE;
		nodeC.rightChild = nodeF;
		nodeF.rightChild = nodeG;
	}
	
	/**
	 * 求二叉树的高度
	 * @author Administrator
	 *
	 */
	public int getHeight(){
		return getHeight(root);
	}
	
	private int getHeight(TreeNode node) {
		if(node == null){
			return 0;
		}
			
		int i = getHeight(node.leftChild);
		int j = getHeight(node.rightChild);
		return (i<j)?j+1:i+1;
	}

	/**
	 * 获取二叉树的结点数
	 * @author Administrator
	 */
	public int getSize(){
		return getSize(root);
	}
	
	
	private int getSize(TreeNode node) {
		if(node == null){
			return 0;
		}else{
			return 1+getSize(node.leftChild)+getSize(node.rightChild);
		}
	}
	
	/**
	 * 求二叉树的叶子节点
	 * 先计算左子树叶子节点，再计算右子树叶子节点
	 * @return
	 */
	public int getLeafSize(){
		return getLeafSize(root);
	}
	
	private int getLeafSize(TreeNode node){
		int leafSize = 0;
		if (node==null) {
			return 0;
		}
		if (node.leftChild==null&&node.rightChild==null) {
			leafSize++;
		}
		leafSize += getLeafSize(node.leftChild);
		leafSize += getLeafSize(node.rightChild);
		return leafSize;
	}
	
	/**
	 * 找二叉树最左边的孩子节点
	 * @return
	 */
	 
	private TreeNode getLeftMostNode(TreeNode node,Stack<TreeNode> stack){
		if (node==null) {
			return null;
		}
		while (node.leftChild!=null) {
			stack.push(node);
			node = node.leftChild;
		}
		return node;
	}
	
	/**
	 * 	后续遍历  - 非递归
		步骤1：
			如果结点有左子树，该结点入栈；
			如果结点没有左子树，访问该结点；
		步骤2：
			如果结点有右子树，重复步骤1；
			如果结点没有右子树（结点访问完毕），根据栈顶指示回退，访问栈顶元素，并访问右子树，重复步骤1
			如果栈为空，表示遍历结束。

	*/

	public void nonPostOrder(TreeNode node){
		if(node == null){
			return;
		} 
		Stack<TreeNode> stack = new Stack<TreeNode>();
		TreeNode treeNode = getLeftMostNode(node,stack);
		while (treeNode!=null) {
			System.out.println("nonRecOrder2 data"+treeNode.getData());
			if (treeNode.rightChild!=null) {
				treeNode = getLeftMostNode(treeNode.rightChild,stack);
			}else if(!stack.isEmpty()){
				treeNode = stack.pop();
			}else {
				treeNode = null;
			}
		}
	}
	
	
	/**
	 * 前序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void preOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			System.out.println("preOrder data:"+node.getData());
			preOrder(node.leftChild);
			preOrder(node.rightChild);
		}
	}
	
	
	/**
	 * 前序遍历——非迭代
	 * 需要借助栈模式进行操作
	 */
	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("nonRecOrder data"+n.getData());
			if(n.rightChild!=null){
				stack.push(n.rightChild);
				
			}
			if(n.leftChild!=null){
				stack.push(n.leftChild);
			}
		}
	}
	/**
	 * 中序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void midOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			midOrder(node.leftChild);
			System.out.println("midOrder data:"+node.getData());
			midOrder(node.rightChild);
		}
	}
	
	/**
	 * 后序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void postOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			postOrder(node.leftChild);
			postOrder(node.rightChild);
			System.out.println("postOrder data:"+node.getData());
		}
	}
	public class TreeNode{
		private int index;
		private String data;
		private TreeNode leftChild;
		private TreeNode rightChild;
		
	
		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(int index,String data){
			this.index = index;
			this.data = data;
			this.leftChild = null;
			this.rightChild = null;
		}
	}
	
	
	public static void main(String[] args){
		BinaryTree binaryTree = new BinaryTree();
		binaryTree.createBinaryTree();
		int height = binaryTree.getHeight();
		System.out.println("treeHeihgt:"+height);
		int size = binaryTree.getSize();
		System.out.println("treeSize:"+size);
		int leafSize = binaryTree.getLeafSize();
		System.out.println("leafSize:"+leafSize);
		
		System.out.println("前序遍历:");
		binaryTree.preOrder(binaryTree.root);
		System.out.println("中序遍历:");
		binaryTree.midOrder(binaryTree.root);
		System.out.println("后序遍历:");
		binaryTree.postOrder(binaryTree.root);
		System.out.println("非递归遍历:");
		binaryTree.nonRecOrder(binaryTree.root);
		System.out.println("非递归后续遍历:");
		binaryTree.nonPostOrder(binaryTree.root);
	}
	
}