Java实现完全二叉树，实现非递归前序，中序，后序遍历

一、定义二叉树

二叉树可以保存在数组，节点在树中位置与数组中索引相关，

比如最后一个根节点 index= N/2向下取整，i 的左节点 索引是 2i 右节点 2i+1 (从一开始)

public class TreeByList {

	//数组记录节点 适用于完全二叉树 不然很浪费空间
	static String[] s = new String[] { "1", "2", "3", "4", "5", "6", "7", "8" };

	public static class Node {
		Node left;
		Node right;
		String data;

		Node(String data) {
			this.data = data;
			this.left = null;
			this.right = null;
		}
	}

	public static LinkedList<Node> nodeList = new LinkedList<Node>();

	public static void initTree() {
		// 初始化所有数组元素为链表节点
		for (String str : s) {
			nodeList.add(new Node(str));
		}
		int len = s.length;
		int rootIndex;
		//完全二叉树特点 最后根节点在数组索引是 总数/2 向下取整
		for (rootIndex = 0; rootIndex < len / 2 - 1; rootIndex++) {
			int leftIndex = rootIndex * 2 + 1;
			int rightIndex = (rootIndex + 1) * 2;
			nodeList.get(rootIndex).left = nodeList.get(leftIndex);
			nodeList.get(rootIndex).right = nodeList.get(rightIndex);
			nodeList.get(rootIndex).data = s[rootIndex];
		}
		// last root node
		nodeList.get(rootIndex).data = s[rootIndex];
		nodeList.get(rootIndex).left = nodeList.get(rootIndex * 2 + 1);
		// 奇数个node最后根节点才有right
		if (len % 2 == 1)
			nodeList.get(rootIndex).right = nodeList.get(rootIndex * 2 + 2);
	}

	// 先序
	public static void preOrderTraverse(Node node) {
		if (node == null)
			return;
		System.out.print(node.data+" ");
		preOrderTraverse(node.left);
		preOrderTraverse(node.right);
	}

	// 中序
	public static void inOrderTraverse(Node node) {
		if (node == null)
			return;
		inOrderTraverse(node.left);
		System.out.print(node.data+" ");
		inOrderTraverse(node.right);
	}

	// 后序
	public static void postOrderTraverse(Node node) {
		if (node == null)
			return;
		postOrderTraverse(node.left);
		postOrderTraverse(node.right);
		System.out.print(node.data+" ");
	}

二、 实现非递归遍历

下图说明了三种遍历打印节点的时机，

使用栈是为了记录访问顺数，方便回头 ，因为树的节点中只保存有左右的位置

而后序遍历要同时保存 左节点 和 右节点 ；

代码如下：

/**
	 * 都是从左到右遍历，先序第一次遇到就打印， 中序第二次遇到（访问左边后）打印， 后序第三次遇到（访问左右之后）打印
	 */
	public static Stack<Node> stack = new Stack<Node>();
	/**
	 *<b>非递归前序遍历</b>
	 */
	public static void preOrderByStack(Node node){
		while(node!=null||!stack.isEmpty()){
			if(node!=null){
				System.out.print(node.data+" ");
				stack.push(node);
				node=node.left;
			}
			else{
				node=stack.pop();
				node=(node.right==null)?null:node.right;
			}
		}
	}
	/**
	 * <b>非递归中序遍历</b><br/>
	 * <b>向前</b>如果节点不为空 或者 栈不空 重复 p指向节点入栈 p指向左节点 <br/>
	 * <b>返回</b> 否则 p==null 出栈，栈顶赋值给p 打印p p指向右节点
	 * <b>从左边回来就打印</b>
	 * <p>中序遍历 栈中保存所有左子树顺序即可  通过right能找到右节点</p>
	 */
	public static void inOrderByStack(Node node) {
		while (node != null || !stack.isEmpty()) {
			if (node != null) {
				stack.push(node);
				node = node.left;
			} 
			//node==null 那么 stack 不空
			else {
				node = stack.pop();
				System.out.print(node.data+" ");
				node = node.right;
			}
		}
	}
	/**
	 *<b>非递归后序遍历</b><br/>
	 *<b>前进:</b>当节点不为空 栈不为空 p入栈（带Left标识） p指向左<br/>
	 *<b>后退:</b>当节点为空 <br/>
	 *p指向出栈节点<br/> 1、p是右节点  打印 p置空 <br/>
	 *2、p是左节点 p 入栈并添加右节点标识 p指向右节点 
	 *<p>只有从右节点返回时才打印</p>
	 *<p>栈保存了左右节点  会出现最左节点带右标识入栈 </p>
	 */
	public static void postOrderByStack(Node node){
		while(node!=null||!stack.isEmpty()){
			//遍历左子树
			if(node!=null){
				node.data+=" L";
				stack.push(node);
				node=node.left;
			}
			//返回
			else{
				node=stack.pop();
				//遇到右子树 从右子树返回 打印
				if(node.data.endsWith(" L")){
					node.data+=" R";
					stack.push(node);
					node=node.right;
				}
				//从左子树返回 向右移动
				else{
					System.out.print(node.data.toString()+" ");
					node=null;
				}
			}
		}
	} 
	public static void main(String[] args) {
		initTree();
		System.out.println("先序");
		preOrderTraverse(nodeList.getFirst());
		System.out.println('\n'+"先序序比较");
		preOrderByStack(nodeList.getFirst());
		System.out.println("中序");
		inOrderTraverse(nodeList.getFirst());
		System.out.println('\n'+"中序比较");
		inOrderByStack(nodeList.getFirst());
		System.out.println('\n'+"后序");
		postOrderTraverse(nodeList.getFirst());
		System.out.println('\n'+"后序比较");
		postOrderByStack(nodeList.getFirst());
		/**关于System.out.println('\n')与 System.out.println(-'\n')的测试 
		 
		  System.out.println('\n');//换行
		  System.out.println(+'\n');
		  System.out.println(+'\r');//回车
		  System.out.println('\r'+'\n');//回车换行
		  */
		/** 这个逻辑关系看一下
		int a=1,b=3;
		while(a>0||b>0){
			
			if(a>0){
				System.out.println("a="+a);}
			else{
				System.out.println("b="+b);}
			a--;
			b--;
		}
		*/
	}

 

在打印后序遍历结果时 出现这样的结果  8 L R 4 L R 5 L R 2 L R 6 L R 7 L R 3 L R 1 L R ，添加了LR 标识是左右打印结束