二叉树的遍历 中序 后序 先序 递归 非递归

先序遍历结果：- + a * - b c d / e f 

中序遍历结果：a + b - c * d - e / f 

后序遍历结果：a b c - d * + e f / - 

层次遍历结果：- + / a * e f - d b c 

 

package lengreen.struct.other;

import lengreen.struct.Iterator;
import lengreen.struct.LinkedList;
import lengreen.struct.Queue;
import lengreen.struct.Stack;
import lengreen.struct.impl.ArrayQueue;
import lengreen.struct.impl.BinaryTreeNode;
import lengreen.struct.impl.DoubleLinkedList;
import lengreen.struct.impl.SingleLinkedStack;

public class BinaryTreeTest {
	private BinaryTreeNode root;

	public static void main(String[] args) {
		BinaryTreeTest bt = new BinaryTreeTest();
		bt.genRoot();
		// Iterator it = bt.midOrder(bt.root, new DoubleLinkedList());
		// Iterator it = bt.lastOrder(bt.root, new DoubleLinkedList());
		// Iterator it = bt.preOrder(bt.root, new DoubleLinkedList());
		Iterator it = bt.levelOrder(bt.root, new DoubleLinkedList());
		// Iterator it = bt.order(1);
		while (!it.isDone()) {
			BinaryTreeNode btn = (BinaryTreeNode) it.currentItem();
			System.out.print(btn.getData().toString() + " ");
			it.next();
		}
	}

	// 层次遍历
	public Iterator levelOrder(BinaryTreeNode rt, LinkedList list) {
		if (rt == null) {
			return null;
		}
		Queue q = new ArrayQueue();
		BinaryTreeNode p = null;
		q.enqueue(rt);
		while (!q.isEmpty()) {
			p = (BinaryTreeNode) q.dequeue();// 取出队首元素，访问之
			list.insertLast(p);
			if (p.hasLeftChild()) {
				q.enqueue(p.getLeftChild());// 如果左节点存在，放入队列中
			}
			if (p.hasRightChild()) {
				q.enqueue(p.getRightChild());// 如果右节点存在，放入队列中
			}
		}
		return list.elements();
	}

	// 二叉树遍历的递归算法
	public void orderRecursion(BinaryTreeNode rt, LinkedList list, int orderby) {
		if (rt == null)
			return; // 递归基,空树直接返回
		switch (orderby) {
		case 1: // 先序遍历访问根结点
			list.insertLast(rt);
			orderRecursion(rt.getLeftChild(), list, orderby); // 遍历左子树
			orderRecursion(rt.getRightChild(), list, orderby); // 遍历右子树
			break;
		case 2: // 中序遍历访问根结点
			orderRecursion(rt.getLeftChild(), list, orderby); // 遍历左子树
			list.insertLast(rt);
			orderRecursion(rt.getRightChild(), list, orderby); // 遍历右子树
			break;
		case 3: // 后续遍历访问根结点
			orderRecursion(rt.getLeftChild(), list, orderby); // 遍历左子树
			orderRecursion(rt.getRightChild(), list, orderby); // 遍历右子树
			list.insertLast(rt);
			break;
		}
	}

	// 二叉树先序遍历非递归算法
	public Iterator preOrder(BinaryTreeNode bt, LinkedList list) {
		Stack s = new SingleLinkedStack();
		BinaryTreeNode p = bt;// 找到最左节点
		while (p != null) {
			while (p != null) {
				list.insertLast(p);// 访问根节点
				if (p.hasRightChild()) {// 右子树压栈
					s.push(p.getRightChild());
				}
				p = p.getLeftChild();// 继续访问左子树直到为空
			}
			if (!s.isEmpty()) {
				p = (BinaryTreeNode) s.pop();// 当当前左子树遍历完成，存右子树的栈退栈
			}
		}
		return list.elements();
	}

	// 找到最左节点
	private BinaryTreeNode goFarLeft(BinaryTreeNode bt, Stack s) {
		if (bt == null) {
			return null;
		}
		while (bt.hasLeftChild()) {
			s.push(bt);
			bt = bt.getLeftChild();
		}
		return bt;
	}

	// 二叉树中序遍历的非递归算法
	public Iterator midOrder(BinaryTreeNode bt, LinkedList list) {
		Stack s = new SingleLinkedStack();
		BinaryTreeNode p = goFarLeft(bt, s);// 找到最左节点
		// 如果最左节点不为空则继续查找
		while (p != null) {
			// 中序访问当前节点
			list.insertLast(p);
			if (p.hasRightChild()) {
				// 如果有右孩子节点，则访问有孩子节点的最左孩子节点
				p = goFarLeft(p.getRightChild(), s);
			} else if (!s.isEmpty()) {
				// 如果没有右孩子节点且栈不为空，则弹栈往回找上一级
				p = (BinaryTreeNode) s.pop();
			} else {
				p = null;// 栈为空则查找完成
			}
		}
		return list.elements();
	}

	// 二叉树后序遍历非递归算法
	public Iterator lastOrder(BinaryTreeNode bt, LinkedList list) {
		Stack s = new SingleLinkedStack();
		BinaryTreeNode p = bt;// 找到最左节点
		BinaryTreeNode pre = null;// 缓存上次访问节点
		// 如果最左节点不为空则继续查找
		while (p != null || !s.isEmpty()) {
			while (p != null) {// 查找最左节点
				s.push(p);
				p = p.getLeftChild();
			}
			if (!s.isEmpty()) {
				// 取出栈顶节点
				p = (BinaryTreeNode) s.peek();
				// 判断当前节点是否是父亲节点的右子节点，如果是
				// 只需访问其父节点即可完成以p的父节点为根节点的子树的访问
				if (!p.hasRightChild() || p.getRightChild() == pre) {
					list.insertLast(p);
					s.pop();
					pre = p;
					p = null;
				} else {
					p = p.getRightChild();
				}
			}
		}
		return list.elements();
	}

	private void genRoot() {
		root = new BinaryTreeNode("-");
		BinaryTreeNode a = new BinaryTreeNode("a");
		BinaryTreeNode b = new BinaryTreeNode("b");
		BinaryTreeNode c = new BinaryTreeNode("c");
		BinaryTreeNode d = new BinaryTreeNode("d");
		BinaryTreeNode e = new BinaryTreeNode("e");
		BinaryTreeNode f = new BinaryTreeNode("f");
		BinaryTreeNode plus = new BinaryTreeNode("+");
		BinaryTreeNode minus = new BinaryTreeNode("-");
		BinaryTreeNode multiply = new BinaryTreeNode("*");
		BinaryTreeNode except = new BinaryTreeNode("/");

		root.setLeftChild(plus);
		root.setRightChild(except);
		plus.setLeftChild(a);
		plus.setRightChild(multiply);
		multiply.setLeftChild(minus);
		multiply.setRightChild(d);
		minus.setLeftChild(b);
		minus.setRightChild(c);
		except.setLeftChild(e);
		except.setRightChild(f);
	}
}