在上文數據結構：樹型結構一文中個，對于樹形結構的定義及術語和應用場景進行了說明。
二叉樹作為樹形結構的一種具體表現形式，我們也在這一篇文章中進行詳細說明。
二叉樹的定義：
二叉樹是樹形結構的一個重要類型。
許多實際問題抽象出來的數據結構往往是二叉樹的形式，即使是一般的樹也能簡單地轉換為二叉樹，而且二叉樹的存儲結構及其算法都較為簡單，因此二叉樹顯得特別重要。
二叉樹(BinaryTree)是n(n≥0)個結點的有限集，它或者是空集(n=0)，或者由一個根結點及兩棵互不相交的、分別稱作這個根的左子樹和右子樹的二叉樹組成。 這個定義是遞歸的。由于左、右子樹也是二叉樹， 因此子樹也可為空樹。
下圖中展現了五種不同基本形態的二叉樹。
二叉樹的五種基本形態
其中
- (a) 為空樹
- (b) 為僅有一個結點的二叉樹
- (c) 是僅有左子樹而右子樹為空的二叉樹
- (d) 是僅有右子樹而左子樹為空的二叉樹
- (e) 是左、右子樹均非空的二叉樹
這里應特別注意的是，二叉樹的左子樹和右子樹是嚴格區分并且不能隨意顛倒的，圖 (c) 與圖 (d) 就是兩棵不同的二叉樹。
二叉樹的遍歷
對于二叉樹來講最主要、最基本的運算是遍歷。
遍歷二叉樹是指以一定的次序訪問二叉樹中的每個結點。
所謂訪問結點是指對結點進行各種操作的簡稱。
例如：查詢結點數據域的內容，或輸出它的值，或找出結點位置，或是執行對結點的其他操作。
遍歷二叉樹的過程實質是把二叉樹的結點進行線性排列的過程。假設遍歷二叉樹時訪問結點的操作就是輸出結點數據域的值，那么遍歷的結果得到一個線性序列。
從二叉樹的遞歸定義可知，一棵非空的二叉樹由根結點及左、右子樹這三個基本部分組成。因此，在任一給定結點上，可以按某種次序執行三個操作：
- 訪問結點本身(N)
- 遍歷該結點的左子樹(L)
- 遍歷該結點的右子樹(R)。
以上三種操作有六種執行次序： NLR、LNR、LRN、NRL、RNL、RLN。
注意：前三種次序與后三種次序對稱，故只討論先左后右的前三種次序。
由于被訪問的結點必是某子樹的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解釋為根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為先根遍歷、中根遍歷和后根遍歷。
二叉樹的java實現
首先創建一棵二叉樹如下圖，然后對這顆二叉樹進行遍歷操作（遍歷操作的實現分為遞歸實現和非遞歸實現），同時還提供一些方法如獲取雙親結點、獲取左孩子、右孩子等。
二叉樹示意圖
Java實現代碼：
import java.util.Stack;
/**
* 二叉樹的鏈式存儲
*/
public class BinaryTree {
/**
* 二叉樹的節點數據結構
*/
private class TreeNode{
/**
* 序號
*/
private int key=0;
/**
* 值
*/
private String data=null;
private boolean isVisted=false;
/**
* 左兒子節點
*/
private TreeNode leftChild=null;
/**
* 右兒子節點
*/
private TreeNode rightChild=null;
/**
* 默認構造方法
*/
public TreeNode(){}
/**
* @param key 層序編碼
* @param data 數據域
*/
public TreeNode(int key,String data){
this.key=key;
this.data=data;
this.leftChild=null;
this.rightChild=null;
}
}
private TreeNode root=null;
/**
* 默認構造方法
* 指定根節點
*/
public BinaryTree(){
root=new TreeNode(1,"rootNode(A)");
}
/**
* 創建一棵二叉樹
* <pre>
* A
* B C
* D E F
* </pre>
* @param root
* @author WWX
*/
public void createBinTree(TreeNode root){
TreeNode newNodeB = new TreeNode(2,"B");
TreeNode newNodeC = new TreeNode(3,"C");
TreeNode newNodeD = new TreeNode(4,"D");
TreeNode newNodeE = new TreeNode(5,"E");
TreeNode newNodeF = new TreeNode(6,"F");
newNodeC.rightChild = newNodeF;//root.rightChild.rightChild=newNodeF;
newNodeB.leftChild = newNodeD;//root.leftChild.leftChild=newNodeD;
newNodeB.rightChild = newNodeE;//root.leftChild.rightChild=newNodeE;
root.leftChild = newNodeB;
root.rightChild = newNodeC;
}
/**
* 判斷跟節點是否為空
* @return 返回根節點是否為空
*/
public boolean isEmpty(){
return root == null;
}
//樹的高度
public int height(){
return height(root);
}
//節點個數
public int size(){
return size(root);
}
/**
* 計算二叉樹節點的高度
* @param subTree 節點
* @return 節點高度
*/
private int height(TreeNode subTree){
if(subTree == null)
return 0;//遞歸結束：空樹高度為0
else{
int i = height(subTree.leftChild);
int j = height(subTree.rightChild);
return (i < j) ? (j + 1) : (i + 1);
}
}
/**
* 計算節點大小
* @param subTree 節點
* @return 節點大小
*/
private int size(TreeNode subTree) {
if(subTree == null){
return 0;
} else {
return 1 + size(subTree.leftChild) + size(subTree.rightChild);
}
}
//返回雙親結點
public TreeNode parent(TreeNode element){
return (root == null || root == element) ? null : parent(root, element);
}
public TreeNode parent(TreeNode subTree,TreeNode element){
if(subTree == null)
return null;
if(subTree.leftChild == element || subTree.rightChild == element)
//返回父結點地址
return subTree;
TreeNode p;
//現在左子樹中找，如果左子樹中沒有找到，才到右子樹去找
if((p = parent(subTree.leftChild, element)) != null)
//遞歸在左子樹中搜索
return p;
else
//遞歸在右子樹中搜索
return parent(subTree.rightChild, element);
}
public TreeNode getLeftChildNode(TreeNode element){
return (element != null) ? element.leftChild : null;
}
public TreeNode getRightChildNode(TreeNode element){
return (element != null) ? element.rightChild : null;
}
public TreeNode getRoot(){
return root;
}
//在釋放某個結點時，該結點的左右子樹都已經釋放，
//所以應該采用后續遍歷，當訪問某個結點時將該結點的存儲空間釋放
public void destroy(TreeNode subTree){
//刪除根為subTree的子樹
if(subTree != null){
//刪除左子樹
destroy(subTree.leftChild);
//刪除右子樹
destroy(subTree.rightChild);
//刪除根結點
subTree=null;
}
}
public void traverse(TreeNode subTree){
System.out.println("key:" + subTree.key + "--name:" + subTree.data);;
traverse(subTree.leftChild);
traverse(subTree.rightChild);
}
//前序遍歷
public void preOrder(TreeNode subTree){
if(subTree != null){
visted(subTree);
preOrder(subTree.leftChild);
preOrder(subTree.rightChild);
}
}
//中序遍歷
public void inOrder(TreeNode subTree){
if(subTree != null){
inOrder(subTree.leftChild);
visted(subTree);
inOrder(subTree.rightChild);
}
}
//后續遍歷
public void postOrder(TreeNode subTree) {
if (subTree != null) {
postOrder(subTree.leftChild);
postOrder(subTree.rightChild);
visted(subTree);
}
}
//前序遍歷的非遞歸實現
public void nonRecPreOrder(TreeNode p){
Stack<TreeNode> stack=new Stack<TreeNode>();
TreeNode node=p;
while(node!=null||stack.size()>0){
while(node!=null){
visted(node);
stack.push(node);
node=node.leftChild;
}
while (stack.size()>0){
node=stack.pop();
node=node.rightChild;
}
}
}
//中序遍歷的非遞歸實現
public void nonRecInOrder(TreeNode p){
Stack<TreeNode> stack =new Stack<BinaryTree.TreeNode>();
TreeNode node =p;
while(node!=null||stack.size()>0){
//存在左子樹
while(node!=null){
stack.push(node);
node=node.leftChild;
}
//棧非空
if(stack.size()>0){
node=stack.pop();
visted(node);
node=node.rightChild;
}
}
}
//后序遍歷的非遞歸實現
public void noRecPostOrder(TreeNode p){
Stack<TreeNode> stack=new Stack<BinaryTree.TreeNode>();
TreeNode node =p;
while(p!=null){
//左子樹入棧
for(;p.leftChild!=null;p=p.leftChild){
stack.push(p);
}
//當前結點無右子樹或右子樹已經輸出
while(p!=null&&(p.rightChild==null||p.rightChild==node)){
visted(p);
//紀錄上一個已輸出結點
node =p;
if(stack.empty())
return;
p=stack.pop();
}
//處理右子樹
stack.push(p);
p=p.rightChild;
}
}
public void visted(TreeNode subTree){
subTree.isVisted=true;
System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
}
//測試
public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
bt.createBinTree(bt.root);
System.out.println("the size of the tree is " + bt.size());
System.out.println("the height of the tree is " + bt.height());
System.out.println("*******(前序遍歷)[ABDECF]遍歷*****************");
bt.preOrder(bt.root);
System.out.println("*******(中序遍歷)[DBEACF]遍歷*****************");
bt.inOrder(bt.root);
System.out.println("*******(后序遍歷)[DEBFCA]遍歷*****************");
bt.postOrder(bt.root);
System.out.println("***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************");
bt.nonRecPreOrder(bt.root);
System.out.println("***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************");
bt.nonRecInOrder(bt.root);
System.out.println("***非遞歸實現****(后序遍歷)[DEBFCA]遍歷*****************");
bt.noRecPostOrder(bt.root);
}
}
執行結果為：
the size of the tree is 6
the height of the tree is 3
*******(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:5--name:E
key:3--name:C
key:6--name:F
*******(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
*******(后序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)
***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:3--name:C
key:6--name:F
***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
***非遞歸實現****(后序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)
