二叉樹概述
數組、向量、鏈表都是一種順序容器,它們提供了按位置訪問數據的手段。而很多情況下,我們需要按數據的值來訪問元素,而不是它們的位置來訪問元素。比如有這樣一個數組int num[3]={1,2,3},我們可以非常快速的訪問數組中下標爲2的數據,也就是說我們知道這個數據的位置,就可以快速訪問。有時候我們是不知道元素的位置,但是卻知道它的值是多少。假設我們有一個變量,存放在num這個數組中,我們知道它的值爲2,卻不知道它下標是多少,也就是說不知道它的位置。這個時候再去數組中訪問這個元素就比較費勁,就得遍歷數組,而且還要保證數組中沒有重複的元素。
二叉樹在很大程度上解決了這個缺點,二叉樹是按值來保存元素,也按值來訪問元素。怎麼做到呢,和鏈表一樣,二叉樹也是由一個個節點組成,不同的是鏈表用指針將一個個節點串接起來,形成一個鏈,如果將這個鏈“拉直”,就像平面中的一條線,是一維的。而二叉樹由根節點開始發散,指針分別指向左右兩個子節點,像樹一樣在平面上擴散,是二維的。示意圖如下:
二叉樹的定義:
二叉樹是樹形結構的一個重要類型。許多實際問題抽象出來的數據結構往往是二叉樹的形式,即使是一般的樹也能簡單地轉換爲二叉樹,而且二叉樹的存儲結構及其算法都較爲簡單,因此二叉樹顯得特別重要。
二叉樹(BinaryTree)是n(n≥0)個結點的有限集,它或者是空集(n=0),或者由一個根結點及兩棵互不相交的、分別稱作這個根的左子樹和右子樹的二叉樹組成。
這個定義是遞歸的。由於左、右子樹也是二叉樹, 因此子樹也可爲空樹。下圖中展現了五種不同基本形態的二叉樹。
其中 (a) 爲空樹, (b) 爲僅有一個結點的二叉樹, (c) 是僅有左子樹而右子樹爲空的二叉樹, (d) 是僅有右子樹而左子樹爲空的二叉樹, (e) 是左、右子樹均非空的二叉樹。這裏應特別注意的是,二叉樹的左子樹和右子樹是嚴格區分並且不能隨意顛倒的,圖 (c) 與圖 (d) 就是兩棵不同的二叉樹。
二叉樹的遍歷
對於二叉樹來講最主要、最基本的運算是遍歷。
遍歷二叉樹 是指以一定的次序訪問二叉樹中的每個結點。所謂 訪問結點 是指對結點進行各種操作的簡稱。例如,查詢結點數據域的內容,或輸出它的值,或找出結點位置,或是執行對結點的其他操作。遍歷二叉樹的過程實質是把二叉樹的結點進行線性排列的過程。假設遍歷二叉樹時訪問結點的操作就是輸出結點數據域的值,那麼遍歷的結果得到一個線性序列。
從二叉樹的遞歸定義可知,一棵非空的二叉樹由根結點及左、右子樹這三個基本部分組成。因此,在任一給定結點上,可以按某種次序執行三個操作:
(1)訪問結點本身(N),
(2)遍歷該結點的左子樹(L),
(3)遍歷該結點的右子樹(R)。
以上三種操作有六種執行次序:
NLR、LNR、LRN、NRL、RNL、RLN。
注意:
前三種次序與後三種次序對稱,故只討論先左後右的前三種次序。
由於被訪問的結點必是某子樹的根,所以N(Node)、L(Left subtlee)和R(Right subtree)又可解釋爲根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱爲先根遍歷、中根遍歷和後根遍歷。
二叉樹的java實現
首先創建一棵二叉樹如下圖,然後對這顆二叉樹進行遍歷操作(遍歷操作的實現分爲遞歸實現和非遞歸實現),同時還提供一些方法如獲取雙親結點、獲取左孩子、右孩子等。
package com.zjn.tree;
import java.util.Stack;
/**
* 二叉樹的鏈式存儲
*
* @author zjn
*/
public class Tree {
private TreeNode root = null;
public Tree() {
root = new TreeNode(1, "rootNode(A)");
}
/**
* 二叉樹的節點數據結構
*
*/
private class TreeNode {
private int key = 0;
private String data = null;
private boolean isVisted = false;
private TreeNode leftChild = null;
private TreeNode rightChild = null;
/**
* @param key
* 層序編碼
* @param data
* 數據域
*/
public TreeNode(int key, String data) {
this.key = key;
this.data = data;
this.leftChild = null;
this.rightChild = null;
}
}
/**
* 創建一棵二叉樹
*
* <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");
root.leftChild = newNodeB;
root.rightChild = newNodeC;
root.leftChild.leftChild = newNodeD;
root.leftChild.rightChild = newNodeE;
root.rightChild.rightChild = newNodeF;
}
public boolean isEmpty() {
return root == null;
}
// 樹的高度
public int height() {
return height(root);
}
// 節點個數
public int size() {
return size(root);
}
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);
}
}
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<Tree.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<Tree.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) {
Tree bt = new Tree();
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);
}
}