二叉树三种遍历 (Java)

以前学数据结构的时候是用C学的，现在重新复习一下数据结构里用的比较多的二叉树，用Java实现。好啦，废话不多说啦！！

我们知道二叉树有三种遍历方式：前序(根左右)、中序(左根右)、后序(左右根)。每种遍历方式其实就是一个递归调用。

步骤：

1、将数组中的元素赋值给二叉树（通常这个过程叫做建树）。

2、然后对于每种遍历方式进行递归调用。

具体代码如下：

import java.util.LinkedList;
import java.util.List;

/**
 * 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历
 * 
 * 参考资料: 数据结构(C语言版)严蔚敏
 * 
 * @author bxk88 @date: 2015-08-21
 * 
 */
public class BinTreeTraverse{

	private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private static List<Node> nodeList = null;

	/**
	 * 内部类：节点
	 * 
	 * @author bxk88 @date: 2015-08-21
	 * 
	 */
	private static class Node {
		Node leftChild;
		Node rightChild;
		int data;

		Node(int newData) {
			leftChild = null;
			rightChild = null;
			data = newData;
		}
	}

	public void createBinTree() {
		nodeList = new LinkedList<Node>();
		// 将一个数组的值依次转换为Node节点
		for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
			nodeList.add(new Node(array[nodeIndex]));
		}
		// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
		for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
			// 左孩子
			nodeList.get(parentIndex).leftChild = nodeList
					.get(parentIndex * 2 + 1);
			// 右孩子
			nodeList.get(parentIndex).rightChild = nodeList
					.get(parentIndex * 2 + 2);
		}
		// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
		int lastParentIndex = array.length / 2 - 1;
		// 左孩子
		nodeList.get(lastParentIndex).leftChild = nodeList
				.get(lastParentIndex * 2 + 1);
		// 右孩子,如果数组的长度为奇数才建立右孩子
		if (array.length % 2 == 1) {
			nodeList.get(lastParentIndex).rightChild = nodeList
					.get(lastParentIndex * 2 + 2);
		}
	}

	/**
	 * 先序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void preOrderTraverse(Node node) {
		if (node == null)
			return;
		System.out.print(node.data + " ");
		preOrderTraverse(node.leftChild);
		preOrderTraverse(node.rightChild);
	}

	/**
	 * 中序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void inOrderTraverse(Node node) {
		if (node == null)
			return;
		inOrderTraverse(node.leftChild);
		System.out.print(node.data + " ");
		inOrderTraverse(node.rightChild);
	}

	/**
	 * 后序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void postOrderTraverse(Node node) {
		if (node == null)
			return;
		postOrderTraverse(node.leftChild);
		postOrderTraverse(node.rightChild);
		System.out.print(node.data + " ");
	}

	public static void main(String[] args) {

		BinTreeTraverse binTree = new BinTreeTraverse();
		binTree.createBinTree();
		// nodeList中第0个索引处的值即为根节点
		Node root = nodeList.get(0);

		System.out.println("先序遍历：");
		preOrderTraverse(root);
		System.out.println();

		System.out.println("中序遍历：");
		inOrderTraverse(root);
		System.out.println();

		System.out.println("后序遍历：");
		postOrderTraverse(root);
	}

}

/*
输出结果：
先序遍历：
1 2 4 8 9 5 3 6 7
中序遍历：
8 4 9 2 5 1 6 3 7
后序遍历：
8 9 4 5 2 6 7 3 1
*/

再上一个例子

/**
 * 二叉树遍历
 *
 *@author baoxukai
 *@version 1.0
 *
 */

class BinaryTree {
 
	 int data;      //根节点数据
	 BinaryTree left;    //左子树
	 BinaryTree right;   //右子树
	 
	 public BinaryTree(int data)    //实例化二叉树类
	 {
		  this.data = data;
		  left = null;
		  right = null;
	 }
	 
	 public void insert(BinaryTree root,int data){     //向二叉树中插入子节点

		  if(data>root.data)                               //二叉树的左节点都比根节点小
		  {
			   if(root.right==null){
					root.right = new BinaryTree(data);
			   }else{
					this.insert(root.right, data);  //递归调用
			   }

		  }else{                                          //二叉树的右节点都比根节点大
			   
			   if(root.left==null){
					root.left = new BinaryTree(data);
			   }else{
					this.insert(root.left, data);
			   }
		  }
	 }

}

//当建立好二叉树类后可以创建二叉树实例，并实现二叉树的先根遍历，中根遍历，后根遍历，代码如下：


public class BinTreeTraverseTest {
 
	 public static void preOrder(BinaryTree root){  //先根遍历
		  if(root!=null){
		   System.out.print(root.data+"-");
		   preOrder(root.left);
		   preOrder(root.right);
		  }
	 }
	 
	 public static void inOrder(BinaryTree root){     //中根遍历

		  if(root!=null){
		   inOrder(root.left);
		   System.out.print(root.data+"--");
		   inOrder(root.right);
		  }
	 }
	 
	 public static void postOrder(BinaryTree root){    //后根遍历

		  if(root!=null){
		   postOrder(root.left);
		   postOrder(root.right);
		   System.out.print(root.data+"---");
		  }
	 }
	 

	 public static void main(String[] args){

		  int[] array = {12,76,35,22,16,48,90,46,9,40};

		  BinaryTree root = new BinaryTree(array[0]);   //创建二叉树
		  for(int i=1;i<array.length;i++){
			 root.insert(root, array[i]);       //向二叉树中插入数据
		  }

		  System.out.println("先根遍历：");
		  preOrder(root);
		  System.out.println();

		  System.out.println("中根遍历：");
		  inOrder(root);
		  System.out.println();

		  System.out.println("后根遍历：");
		  postOrder(root);
	 }


 }

 /*
 程序输出：
先根遍历：
12-9-76-35-22-16-48-46-40-90-
中根遍历：
9--12--16--22--35--40--46--48--76--90--
后根遍历：
9---16---22---40---46---48---35---90---76---12---
*/