java数据结构之二叉树的遍历

二叉树的遍历：

先序遍历二叉树的操作是：

若二叉树为空，则空操作；否则

1.访问根结点

2.先序遍历左子树

3先序遍历右子树

中序遍历二叉树的操作是：

若二叉树为空，则空操作；否则

1.中序遍历左子树

2.访问根结点

3.中序遍历右子树

后序遍历二叉树的操作是：

若二叉树为空，则空操作；否则

1.后序遍历左子树

2.后序遍历右子树

3.访问根结点

基本代码：

package Tree;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

class BTree {
	String value;
	BTree lchild, rchild;

	public BTree() {
	}

	public BTree(String value) {
		this.value = value;
		lchild = null;
		rchild = null;
	}

	public BTree getLchild() {
		return lchild;
	}

	public void setLchild(BTree lchild) {
		this.lchild = lchild;
	}

	public BTree getRchild() {
		return rchild;
	}

	public void setRchild(BTree rchild) {
		this.rchild = rchild;
	}

}

public class BineryTree1 {
	private BTree root;

	public BineryTree1() {
	}

	public BineryTree1(BTree root) { // 构造函数
		this.root = root;
	}

	// 创建二叉树
	public void createBiTree() {
		Scanner scn = null;
		try {
			scn = new Scanner(new File("F:\\input.txt"));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		this.root = createBiTree(root, scn);
	}

	private BTree createBiTree(BTree node, Scanner scn) {

		String temp = scn.next();
		if (temp.trim().equals("#")) {
			return null;
		} else {
			node = new BTree(temp);
			node.setLchild(createBiTree(node.getLchild(), scn));
			node.setRchild(createBiTree(node.getRchild(), scn));
			return node;
		}
	}

	// 遍历二叉树
	// 前序递归遍历二叉树
	public void preOrderTree(BTree node) {
		if (node == null)
			return;
		System.out.print(node.value + " ");
		preOrderTree(node.lchild);
		preOrderTree(node.rchild);
	}

	// 用栈非递归先序遍历
	private void preOderTraverse() {
		Stack<BTree> stack = new Stack<BTree>();
		BTree node = root;

		while (node != null | !stack.isEmpty()) {
			while (node != null) {
				System.out.print(node.value + " ");
				stack.push(node);
				node = node.getLchild();
			}
			node = stack.pop();
			node = node.getRchild();
		}
	}

	// 中序递归遍历二叉树
	public void inOrderTree(BTree node) {
		if (node == null)
			return;
		inOrderTree(node.lchild);
		System.out.print(node.value + " ");
		inOrderTree(node.rchild);

	}

	// 用栈来非递归中序遍历二叉树
	public void inOrderTraverse() {
		Stack<BTree> stack = new Stack<BTree>();
		BTree node = root;
		while (node != null || !stack.isEmpty()) {
			while (node != null) {
				stack.push(node);
				node = node.getLchild();
			}
			node = stack.pop();
			System.out.print(node.value + " ");
			node = node.getRchild();
		}
	}

	// 后序递归遍历二叉树

	public void postOrderTree(BTree node) {
		if (node == null)
			return;
		postOrderTree(node.lchild);
		postOrderTree(node.rchild);
		System.out.print(node.value + " ");

	}

	// 非递归后序遍历二叉树
	public void postOderTraverse() {
		Stack<BTree> stack = new Stack<BTree>();
		BTree node = root;
		BTree n = root;
		while (node != null) {
			// 左子树入栈
			for (; node.getLchild() != null; node = node.getLchild()) {

				stack.push(node);
			}
			// 当节点无右子树或者右子树已经输出
			while (node != null && (node.getRchild() == null)
					|| (node.getRchild() == n)) {
				System.out.print(node.value + " ");
				n = node;// 记录已经输出的节点
				if (stack.isEmpty())
					return;
				node = stack.pop();

			}// 处理右子树
			stack.push(node);
			node = node.getRchild();
		}
	}

	// 层次遍历二叉树，用队列

	public void levelTreverse() {

		Queue<BTree> queue = new LinkedList<BTree>();
		BTree node = root;
		queue.add(node);
		while (!queue.isEmpty()) {
			node = queue.remove();
			if (node != null) {
				System.out.print(node.value + " ");
				queue.add(node.getLchild());
				queue.add(node.getRchild());
			}

		}

	}

	public static void main(String[] args) {
		BineryTree1 tree = new BineryTree1();
		tree.createBiTree();
		tree.preOrderTree(tree.root);
		System.out.println();
		tree.inOrderTree(tree.root);
		System.out.println();
		tree.postOrderTree(tree.root);
		System.out.println();
		tree.inOrderTraverse();
		System.out.println();
		tree.preOderTraverse();
		System.out.println();
		tree.postOderTraverse();
		System.out.println();
		tree.levelTreverse();

	}

}