二叉树的定义：
二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。
二叉树的遍历方式主要有：先序遍历(NLR)，中序遍历(LNR)，后序遍历(LRN)，和层次遍历。
注意：
由二叉树的先序序列和中序序列可以唯一地确定一颗二叉树；
由二叉树的后序序列和中序序列可以唯一地确定一颗二叉树；
由二叉树的层序序列和中序序列可以唯一地确定一棵二叉树；
但，由二叉树的先序序列和后序序列无法唯一地确定一棵二叉树。
Java实现链式存储的二叉树以及其各种遍历算法：
树节点：
public class TreeNode<E> { private E data; //数据域 private TreeNode<E> lchild; //左孩子 private TreeNode<E> rchild; //右孩子 TreeNode(){} TreeNode(E e){ this.data = e; } TreeNode(E data,TreeNode<E> lchild, TreeNode<E> rchild){ this.data = data; this.lchild = lchild; this.rchild = rchild; } public void setData(E data){ this.data = data; } public E getData(){ return this.data; } public void setLchild(TreeNode<E> lchild){ this.lchild = lchild; } public TreeNode<E> getLchild(){ return this.lchild; } public void setRchild(TreeNode<E> rchild){ this.rchild = rchild; } public TreeNode<E> getRchild(){ return this.rchild; } }
二叉树的Java实现：
import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Stack; /** * @author Cherish * 二叉树的链式存储结构 * @param <E> */ public class BinaryTree<E> { private TreeNode<E> root; //根节点 private List<TreeNode> nodeList = null; //二叉树节点的链式结构 public BinaryTree(){ } public BinaryTree(TreeNode<E> root){ this.root = root; } //把一个数组转化为一颗完全二叉树 public TreeNode<E> buildTree(E[] array){ nodeList = new LinkedList<TreeNode>(); //将数组中的元素依次转换为TreeNode节点，存放于链表中 for(int i=0; i< array.length; i++){ nodeList.add(new TreeNode(array[i])); } //对前（array.length / 2 - 1）个父节点，按照父节点与孩子节点的数字关系建立完全二叉树 //对完全二叉树，按从上到下，从左到右的顺序依次编号0,1,2,3....N,则i>0的节点，其左孩子为（2*i+1）， //其右孩子为（2*i+2） for(int j=0; j < (array.length/2-1);j++){ //左孩子 nodeList.get(j).setLchild(nodeList.get(j*2+1)); //右孩子 nodeList.get(j).setRchild(nodeList.get(j*2+2)); } //最后一个父节点：因为最后一个父节点可能没有右孩子，所以单独处理 int index = array.length/2 -1; //左孩子 nodeList.get(index).setLchild(nodeList.get(index*2+1)); //右孩子：如果数组的长度为奇数才有右孩子 if(array.length % 2 == 1){ nodeList.get(index).setRchild(nodeList.get(index*2+2)); } root=nodeList.get(0); //设置根节点 return root; } //得到树的高度 public int height(TreeNode<E> node){ if(node == null){ return 0; }else{ int i = height(node.getLchild()); int j = height(node.getRchild()); return (i<j)?(j+1):(i+1); } } //得到节点的个数 public int size(TreeNode<E> node){ if(node == null){ return 0; }else{ return 1+ size(node.getLchild())+size(node.getRchild()); } } //递归实现先序遍历 NLR public void preOrder(TreeNode<E> node){ if(node != null){ System.out.print(node.getData() + " "); preOrder(node.getLchild()); preOrder(node.getRchild()); } } //非递归实现先序遍历 NLR public void nonRecPreOrder(TreeNode<E> node){ Stack<TreeNode<E>> nodeStack = new Stack<TreeNode<E>>(); TreeNode<E> nodeTemp = node; //nodeTemp作为遍历指针 while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环 if(nodeTemp != null){ //根指针非空，遍历左子树 nodeStack.push(nodeTemp); //根指针进栈 System.out.print(nodeStack.peek().getData() + " "); //根指针退栈，访问根节点 nodeTemp = nodeTemp.getLchild(); //每遇到非空二叉树先向左走 }else{ //再向右子树走 nodeTemp = nodeStack.pop(); nodeTemp = nodeTemp.getRchild(); } } } //递归实现中序遍历 LNR public void inOrder(TreeNode<E> node){ if(node != null){ inOrder(node.getLchild()); System.out.print(node.getData() + " "); inOrder(node.getRchild()); } } //非递归实现中序遍历 LNR public void nonRecInOrder(TreeNode<E> node){ Stack<TreeNode<E>> nodeStack = new Stack<TreeNode<E>>(); TreeNode<E> nodeTemp = node; //nodeTemp作为遍历指针 while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环 if(nodeTemp != null){ //根指针非空，遍历左子树 nodeStack.push(nodeTemp); //根指针进栈 nodeTemp = nodeTemp.getLchild(); //每遇到非空二叉树先向左走 }else{ nodeTemp = nodeStack.pop(); //根指针退栈，访问根节点 System.out.print(nodeTemp.getData() +" "); nodeTemp = nodeTemp.getRchild(); //再向右子树走 } } } //递归实现后序遍历 LNR public void postOrder(TreeNode<E> node){ if(node != null){ postOrder(node.getLchild()); postOrder(node.getRchild()); System.out.print(node.getData() + " "); } } //非递归实现后序遍历 LNR public void nonRecPostOrder(TreeNode<E> node){ Stack<TreeNode<E>> nodeStack = new Stack<TreeNode<E>>(); TreeNode<E> nodeTemp = node; //nodeTemp作为遍历指针 TreeNode<E> preNode = null; //表示最近一次访问的节点 while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环 while(nodeTemp != null){ //一直向左走，遍历左子树 nodeStack.push(nodeTemp); nodeTemp = nodeTemp.getLchild(); } nodeTemp = nodeStack.peek(); if(nodeTemp.getRchild()==null || nodeTemp.getRchild() == preNode){ //右子树为空或右子树已被访问时，该节点出栈 nodeTemp = nodeStack.pop(); System.out.print(nodeTemp.getData()+" "); preNode = nodeTemp; //将该节点赋值给最近一个访问节点 nodeTemp = null; //此处很重要，将刚出栈节点设置为空，对应于while循环的条件之一，否则陷入死循环 }else{ nodeTemp = nodeTemp.getRchild(); //遍历右子树 } } } //层次遍历 public void levelOrder(TreeNode<E> root){ Queue<TreeNode<E>> nodeQueue = new LinkedList<TreeNode<E>>(); TreeNode<E> node = null; nodeQueue.add(root); //将根节点入队 while(!nodeQueue.isEmpty()){ //队列不空循环 node = nodeQueue.peek(); System.out.print(node.getData()+" "); nodeQueue.poll(); //队头元素出队 if(node.getLchild() != null){ //左子树不空，则左子树入队列 nodeQueue.add(node.getLchild()); } if(node.getRchild() != null){ //右子树不空，则右子树入队列 nodeQueue.add(node.getRchild()); } } } public static void main(String args[]){ //将一个数组转化为一颗完全二叉树 Object[] array = {1,2,3,4,5,6,7,8}; BinaryTree bt = new BinaryTree(); TreeNode root = bt.buildTree(array); System.out.print("树的高度："); System.out.println(bt.height(root)); System.out.print("节点的个数："); System.out.println(bt.size(root)); System.out.println("先序遍历："); bt.preOrder(root); System.out.println("\n"+"非递归先序遍历："); bt.nonRecPreOrder(root); System.out.println(); System.out.println("中序遍历："); bt.inOrder(root); System.out.println("\n"+"非递归中序遍历："); bt.nonRecInOrder(root); System.out.println(); System.out.println("后序遍历："); bt.postOrder(root); System.out.println("\n"+"非递归后序遍历："); bt.nonRecPostOrder(root); System.out.println(); System.out.println("层次遍历："); bt.levelOrder(root); //手工构建一颗二叉树 TreeNode nodeA = new TreeNode("A"); TreeNode nodeB = new TreeNode("B"); TreeNode nodeC = new TreeNode("C"); TreeNode nodeD = new TreeNode("D"); TreeNode nodeE = new TreeNode("E"); TreeNode nodeF = new TreeNode("F"); TreeNode nodeG = new TreeNode("G"); TreeNode nodeH = new TreeNode("H"); TreeNode nodeI = new TreeNode("I"); nodeA.setLchild(nodeB); nodeA.setRchild(nodeD); nodeB.setRchild(nodeC); nodeD.setLchild(nodeE); nodeD.setRchild(nodeF); nodeF.setLchild(nodeG); nodeF.setRchild(nodeI); nodeG.setRchild(nodeH); System.out.println("\n\n"+"*****************"); System.out.print("树的高度："); System.out.println(bt.height(nodeA)); System.out.print("节点的个数："); System.out.println(bt.size(nodeA)); System.out.println("先序遍历："); bt.preOrder(nodeA); System.out.println(); System.out.println("中序遍历："); bt.inOrder(nodeA); System.out.println(); System.out.println("后序遍历："); bt.postOrder(nodeA); System.out.println(); System.out.println("层次遍历："); bt.levelOrder(nodeA); } }
上述程序的运行结果：
树的高度：4 节点的个数：8 先序遍历： 1 2 4 8 5 3 6 7 非递归先序遍历： 1 2 4 8 5 3 6 7 中序遍历： 8 4 2 5 1 6 3 7 非递归中序遍历： 8 4 2 5 1 6 3 7 后序遍历： 8 4 5 2 6 7 3 1 非递归后序遍历： 8 4 5 2 6 7 3 1 层次遍历： 1 2 3 4 5 6 7 8 ***************** 树的高度：5 节点的个数：9 先序遍历： A B C D E F G H I 中序遍历： B C A E D G H F I 后序遍历： C B E H G I F D A 层次遍历： A B D C E F G I H
