java创建二叉树并实现非递归中序遍历二叉树

java创建二叉树并递归遍历二叉树前面已有讲解：http://www.cnblogs.com/lixiaolun/p/4658659.html。

在此基础上添加了非递归中序遍历二叉树：

二叉树类的代码：

package binarytree;

import linkedstack.LinkStack;
import linkqueue.LinkQueue;

public class BinaryTree {

	class Node
	{
		public Object data;
		public Node lchild;
		public Node rchild;

		public Node(Object data)
		{
			this.data = data;
			this.lchild = null;
			this.rchild = null;
		}
	}

	//根节点
	private Node root = null;
	private Node node = null;
	/**
	 * 创建树
	 *
	 * 以完全二叉树的格式来创建（子树不存在的用0填充），
	 * 对完全二叉树中每一个节点从0开始进行编号，
	 * 那么第i个节点的左孩子的编号为2*i+1，右孩子为2*i+2。
	 *
	 * */
	void createTree(String strtree)
	{
		LinkQueue lQueue = new LinkQueue();
		lQueue.initQueue();
		/**
		 * 完全二叉树中第i层的结点的个数最多为第1到i-1层上所有节点的个数和
		 * 所以父节点的个数最多为N-1个，N表示节点个数
		 * */
		for(int parentIndex =0; parentIndex<strtree.split(" ").length/2;parentIndex++)
		{
			if(root == null)
			{
				root= new Node(strtree.split(" ")[parentIndex]);
				//左孩子
				root.lchild = new Node(strtree.split(" ")[parentIndex*2+1]);
				lQueue.enQueue(root.lchild);
				//右孩子
				root.rchild = new Node(strtree.split(" ")[parentIndex*2+2]);
				lQueue.enQueue(root.rchild);
			}else
			{
				if(!lQueue.isEmpty() && parentIndex*2+1<strtree.split(" ").length)//队列不空
				{
					node = (Node) lQueue.deQueue();
					if(parentIndex*2+1<strtree.split(" ").length)
					{
						//左孩子
						node.lchild = new Node(strtree.split(" ")[parentIndex*2+1]);
						lQueue.enQueue(node.lchild);
					}
					if(parentIndex*2+2<strtree.split(" ").length)
					{
						//右孩子
						node.rchild = new Node(strtree.split(" ")[parentIndex*2+2]);
						lQueue.enQueue(node.rchild);
					}
				}else
				{
					return;
				}
			}
		}
	}

	/**
	 * 先序遍历二叉树
	 * */
	void preOrderTraverse(Node node)
	{
		if(node == null)
		{
			return;
		}
		visit(node);
		preOrderTraverse(node.lchild);
		preOrderTraverse(node.rchild);
	}
	/**
	 * 中序遍历二叉树
	 * */
	void inOrderTraverse(Node node)
	{
		if(node == null)
		{
			return;
		}
		inOrderTraverse(node.lchild);
		visit(node);
		inOrderTraverse(node.rchild);
	}

	/**
	 * 非递归中序遍历二叉树
	 * */
	void inOrderTraverse2(Node node)
	{
		if(node == null)
		{
			return;
		}
		LinkStack lStack = new LinkStack();
		lStack.initStack();//初始化栈
		Node p =node;
		while(p!=null || !lStack.isEmpty())
		{
			if(p!=null)//遍历左子树，向左走到尽头，并将走过的节点入栈
			{
				lStack.push(p);
				p=p.lchild;
			}else//访问节点，向右走一步
			{
				p=(Node) lStack.pop();
				visit(p);
				p=p.rchild;
			}
		}
	}

	/**
	 * 后序遍历二叉树
	 * */
	void postOrderTraverse(Node node)
	{
		if(node == null)
		{
			return;
		}
		postOrderTraverse(node.lchild);
		postOrderTraverse(node.rchild);
		visit(node);
	}

	/**
	 * 打印二叉树
	 * */
	public void print()
	{
		System.out.print("先序遍历：");
		preOrderTraverse(root);
		System.out.print("\n中序遍历：");
		inOrderTraverse(root);
		System.out.print("\n非递归中序遍历：");
		inOrderTraverse2(root);
		System.out.print("\n后序遍历：");
		postOrderTraverse(root);

	}

	/**
	 * 访问节点
	 * */
	private void visit(Node node)
	{
		if(!node.data.equals("0"))
		{
			System.out.print(node.data);
		}
	}
}

　　

测试类代码：

package binarytree;

public class BinaryTreeMain {

	public static void main(String[] args) {
		BinaryTree binaryTree = new BinaryTree();
		String strtree="- + / a * e f 0 0 b - 0 0 0 0 0 0 0 0 0 0 c d";//0表示没有值的位置
		binaryTree.createTree(strtree);
		binaryTree.print();
	}
}