二叉树的构建及各种遍历方式

树型结构是一种非常重要的非线性数据结构，在计算机领域应用广泛，本文以二叉树为例，详细介绍二叉树的构建及遍历方式，其中包含递归实现的先序遍历、中序遍历及后续遍历，以及非递归实现的深度优先遍历、广度优先遍历。

以下是Java代码实现：

package me.geed.algorithms;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinaryTree {
	/**二叉树根节点*/
	private Node rootNode;
	
	/**
	 * 由整数数组构造二叉树
	 * @param array
	 */
	public BinaryTree(int[] array) {
		rootNode = createBinaryTreeNode(array, 0);
	}
		
	public class Node {
		private int value;
		private Node leftChild;
		private Node rightChild;
		
		public Node(int value) {
			this.value = value;
		}
	}
	
	/**
	 * 先序遍历二叉树--递归方式
	 * @param node
	 */
	public void preOrderTraverse(Node node) {
		if (node != null) {
			System.out.print(node.value + "  ");
			preOrderTraverse(node.leftChild);
			preOrderTraverse(node.rightChild);
		}
	}
	
	/**
	 * 中序遍历二叉树--递归方式
	 * @param node
	 */
	public void midOrderTraverse(Node node) {
		if (node != null) {			
			midOrderTraverse(node.leftChild);
			System.out.print(node.value + "  ");
			midOrderTraverse(node.rightChild);
		}
	}
	
	/**
	 * 后序遍历二叉树--递归方式
	 * @param node
	 */
	public void postOrderTraverse(Node node) {
		if (node != null) {			
			postOrderTraverse(node.leftChild);			
			postOrderTraverse(node.rightChild);
			System.out.print(node.value + "  ");
		}
	}
	
	/**
	 * 深度优先遍历（跟先序遍历是一样的）--非递归实现
	 * 借助栈先进后出的特点，示例仅演示原理，如果追求效率可以使用ArrayDeque
	 */
	public void depthOrderTraverse(){
		if (rootNode == null) {
			return;
		}
		Stack<Node> stack = new Stack<Node>();
		stack.push(rootNode);
		while (!stack.isEmpty()) {
			Node node = stack.pop();
			System.out.print(node.value + "  ");
			if (node.rightChild != null) {
				stack.push(node.rightChild);
			}
			if (node.leftChild != null) {
				stack.push(node.leftChild);
			}
		}
	}
	
	/**
	 * 广度优先遍历（跟层序遍历是一样的）--非递归实现
	 * 借助链表尾部进、头部出的特点，如追求效率可使用ArrayDeque
	 */
	public void levelOrderTraverse() {
		if (rootNode == null) {
			return;
		}
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(rootNode);
		while (!queue.isEmpty()) {
			Node node = queue.remove();
			System.out.print(node.value + "  ");
			if (node.leftChild != null) {
				queue.add(node.leftChild);
			}
			if (node.rightChild != null) {
				queue.add(node.rightChild);
			}
		}
	}
	
	/**
	 * 创建二叉树的节点
	 * @param array
	 * @param index
	 * @return
	 */
	public Node createBinaryTreeNode(int[] array, int index) {
		if (index < array.length) {
			int value = array[index];
			if (value != 0) {
				Node node = new Node(value);
				node.leftChild = createBinaryTreeNode(array, index * 2 + 1);
				node.rightChild = createBinaryTreeNode(array, index * 2 + 2);
				return node;
			}
		}
		return null;		
	}

	/**
	 * 入口函數
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {1, 3, 6, 8, 12, 7, 29, 47, 35, 0, 99, 0, 0, 68, 0};
		BinaryTree bTree = new BinaryTree(array);
		/**  
		 * 由以上数组生成的二叉树结构如下，0表示空节点
		 * 
	     *                  1 
	     *                /   \ 
	     *               3     6 
	     *              / \   / \ 
	     *             8  12 7  29 
	     *            / \   \   / 
	     *           47 35  99 68  
	     */  
		System.out.println("先序遍历二叉树");
		bTree.preOrderTraverse(bTree.rootNode);
		
		System.out.println("\n中序遍历二叉树");
		bTree.midOrderTraverse(bTree.rootNode);
		
		System.out.println("\n后序遍历二叉树");
		bTree.postOrderTraverse(bTree.rootNode);
		
		System.out.println("\n深度优先遍历二叉树");
		bTree.depthOrderTraverse();
		
		System.out.println("\n广度优先遍历二叉树");
		bTree.levelOrderTraverse();

	}

}

以上代码中的注释已经描述的比较清楚，程序运行结果如下：

先序遍历二叉树
1  3  8  47  35  12  99  6  7  29  68  
中序遍历二叉树
47  8  35  3  12  99  1  7  6  68  29  
后序遍历二叉树
47  35  8  99  12  3  7  68  29  6  1  
深度优先遍历二叉树
1  3  8  47  35  12  99  6  7  29  68  
广度优先遍历二叉树
1  3  6  8  12  7  29  47  35  99  68