2. 程式人生 > >java數據結構之三叉鏈表示的二叉樹

java數據結構之三叉鏈表示的二叉樹

阿新 • • 發佈：2017-05-27
按層遍歷 postorder while ldl 字符串 param pub link 根節點

三叉鏈表示的二叉樹定義
所畏的三叉鏈表示是指二叉樹由指向左孩子結點、右孩子結點、父親結點【三叉】的引用（指針）數據和數據組成。
package datastructure.tree.btree;
/**
* 三叉鏈表示的二叉樹定義
* @author Administrator
*
*/
public class BinTreeNode{
private Object data; // 數據域
private BinTreeNode parent; // 父節點
private BinTreeNode lChild; // 左孩子
private BinTreeNode rChild; // 右孩子
private int height; // 以該節點為根的子樹的高度
private int size; // 該節點子孫數（包括結點本身）

public BinTreeNode() {
this(null);
}

public BinTreeNode(Object e) {
data = e;
height = 0;
size = 1;
parent = lChild = rChild = null;
}
//************ Node接口方法 *************/
/**
* 獲得結點的數據
*/
public Object getData() {
return data;
}

public void setData(Object obj) {
data = obj;
}


//-------------輔助方法，判斷當前結點位置的情況------------
/**
* 判斷是否有父親
* @return
*/
public boolean hasParent() {
return parent != null;
}

/**
* 判斷是否有左孩子
* @return 如果有左孩子結點返回true,否則返回false
*/
public boolean hasLChild() {
return null != lChild;
}

/**
* 判斷是否有右孩子
* @return
*/
public boolean hasRChild() {
return null != rChild;
}

/**
* 判斷是否為葉子結點
* @return
*/
public boolean isLeaf() {
return (!hasLChild() && !hasRChild());
}

/**
* 判斷是否為某節點的左孩子
* @return
*/
public boolean isLChild() {
return (hasParent() && this == parent.lChild);
}

/**
* 判斷是否為某結點的右孩子
* @return
*/
public boolean isRChild() {
return (hasParent()) && this == parent.rChild;
}

//-------------- 與height相關的方法-----------------
/**
* 取結點的高度，即以該節點為根的樹的高度
* @return
*/
public int getHeight() {
return height;
}

/**
* 更新當前結點及其祖先的高度
*/
public void updateHeight() {
int newH = 0;// 新高度初始化為0，高度等於左右子樹加1中的較大值
if (hasLChild())
newH = Math.max(newH, (lChild.getHeight() + 1));// //////////////???
if (hasRChild())
newH = Math.max(newH, (rChild.getHeight() + 1));// 先0和左孩子的高度加1進行比較，後左孩子高度加1和右孩子高度加1進行比較
if (newH == height)
return; // 高度沒有發生變化則直接返回
height = newH; // 否則，更新高度
if (hasParent()) // 遞歸更新祖先的高度
parent.updateHeight();
}

/********* 與size相關的方法 **********/
/**
* 取以該節點為根的樹的結點數
* @return
*/
public int getSize() {
return size;
}

/**
* 更新當前結點及祖先的子孫數
*/
public void updateSize() {
size = 1; // 初始化為1，結點本身
if (hasLChild())
size = size + lChild.getSize(); // 加上左子樹的規模
if (hasRChild())
size = size + rChild.getSize(); // 加上右子樹的規模
if (hasParent())
parent.updateSize();
}

/********** 與parent相關的方法 **********/
/**
* 取父節點
* @return
*/
public BinTreeNode getParent() {
return parent;
}

/**
* 斷開與父親的關系
*/
public void sever() {
if (!hasParent())
return;
if (isLChild())
parent.lChild = null;
else
parent.rChild = null;
parent.updateHeight(); // 更新父節點及其祖先的高度
parent.updateSize(); // 更新父節點及其祖先的規模
parent = null;
}

//********** 與lChild相關的方法 ********/
/**
* 取左孩子
* @return
*/
public BinTreeNode getLChild() {
return lChild;
}

/**
* 設置當前結點的左孩子，返回原左孩子
* @param lc
* @return
*/
public BinTreeNode setLChild(BinTreeNode lc) {
BinTreeNode oldLC = this.lChild;
if (hasLChild()) {
lChild.sever();
} // 斷開當前左孩子與結點的關系
if (null != lc) {
lc.sever(); // 判斷lc與其父節點的關系
this.lChild = lc; // 確定父子關系
lc.parent = this;
this.updateHeight(); // 更新當前結點及其祖先的高度
this.updateSize(); // 更新當前結點及其祖先的規模
}
return oldLC; // 返回原左孩子
}

//********** 與rChild相關的方法 *********/
/**
* 取右孩子
* @return
*/
public BinTreeNode getRChild() {
return rChild;
}

/**
* 設置當前結點為右孩子，返回原右孩子
* @param rc
* @return
*/
public BinTreeNode setRChild(BinTreeNode rc) {
BinTreeNode oldRC = this.rChild;
if (hasRChild()) {
rChild.sever();
} // 斷開當前右孩子與結點的關系
if (null != rc) {
rc.sever(); // 斷開rc與其父節點的關系
this.rChild = rc; // 確定父子關系
rc.parent = this;
this.updateHeight(); // 更新當前結點及其祖先的高度
this.updateSize(); // 更新當前結點及其祖先的規模
}
return oldRC; // 返回原右孩子
}
/**
* 重寫toString方法
*/
public String toString() {
return "" + data;
}

}


三叉鏈表示的二叉樹的遍歷


package datastructure.tree.btree;
import java.util.*;
import datastructure.common.Strategy;
import datastructure.queue.Queue;
import datastructure.queue.ArrayQueue;
/**
* 三叉鏈表示的二叉樹的遍歷
* @author luoweifu
*
*/
public class BinaryTreeOrder {
private int leafSize = 0;
private BinTreeNode root = null;
Strategy strategy = new StrategyEqual();

/**
* 構造函數，傳入樹的根結點
* @param node
* 樹的根結點
*/
public BinaryTreeOrder(BinTreeNode node) {
this.root = node;
Strategy strategy = new StrategyEqual();
}

public BinTreeNode getRoot() {
return root;
}

/**
* 前序遍歷
*
* @return 返回一個Iterator容器
*/
public Iterator preOrder() {
List<BinTreeNode> list = new LinkedList();
preOrderRecursion(this.root, list);
return list.iterator();
}

/**
* 遞歸定義前序遍歷
* @param rt
* 樹根結點
* @param list
* LinkedList容器
*/
private void preOrderRecursion(BinTreeNode rt, List list) {
if (null == rt)
return; // 遞歸基，空樹直接返回
list.add(rt); // 訪問根節點
preOrderRecursion(rt.getLChild(), list);// 遍歷左子樹
preOrderRecursion(rt.getRChild(), list);// 遍歷右子樹
}

/**
* 中序遍歷
*
* @return
*/
public Iterator inOrder() {
List<BinTreeNode> list = new LinkedList();
inOrderRecursion(this.root, list);
return list.iterator();
}

/**
* 遞歸定義中序遍歷
* @param rt
* 樹根結點
* @param list
* LinkedList容器
*/
private void inOrderRecursion(BinTreeNode rt, List list) {
if (null == rt)
return; // 遞歸基，空樹直接返回
inOrderRecursion(rt.getLChild(), list);// 遍歷左子樹
list.add(rt); // 訪問根節點
inOrderRecursion(rt.getRChild(), list);// 遍歷右子樹
}

/**
* 後序遍歷
* @return
*/
public Iterator postOrder() {
List<BinTreeNode> list = new LinkedList();
postOrderRecursion(this.root, list);
return list.iterator();
}

/**
* 遞歸定義後序遍歷
* @param rt
* 樹根結點
* @param list
* LinkedList容器
*/
private void postOrderRecursion(BinTreeNode rt, List list) {
if (null == rt)
return; // 遞歸基，空樹直接返回
postOrderRecursion(rt.getLChild(), list);// 遍歷左子樹
postOrderRecursion(rt.getRChild(), list);// 遍歷右子樹
list.add(rt);// 訪問根節點
}

/**
* 按層遍歷
* @return
*/
public Iterator levelOrder() {
List<BinTreeNode> list = new LinkedList();
levelOrderTraverse(this.root, list);
return list.iterator();
}

/**
* 使用隊列完成二叉樹的按層遍歷
* @param rt
* @param list
*/
private void levelOrderTraverse(BinTreeNode rt, List list) {
if (null == rt)
return;
Queue q = new ArrayQueue();
q.push(rt);// 根節點入隊列
while (!q.isEmpty()) {
BinTreeNode p = (BinTreeNode) q.deQueue(); // 取出隊首節點p並訪問
list.add(p);
if (p.hasLChild())
q.push(p.getLChild()); // 將p的非空左右孩子依次入隊列
if (p.hasRChild())
q.push(p.getRChild());
}
}

/**
* 在樹中查找元素e，並返回其所在的結點
* @param e 要查找的數據元素
* @return 返回找到的結點
*/
public BinTreeNode find(Object e) {
return searchE(root, e);
}

/**
* 遞歸查找元素e
* @param rt 樹的根
* @param e 要查找的數據元素
* @return 返回找到的結點
*/
private BinTreeNode searchE(BinTreeNode rt, Object e) {
if (null == rt)
return null;
if (strategy.equal(rt.getData(), e))
return rt;
BinTreeNode v = searchE(rt.getLChild(), e);
if (null == v)
v = searchE(rt.getRChild(), e);
return v;
}
/**
* 打印二叉樹
* @return
*/
public String printBinTree() {
StringBuilder sb = new StringBuilder();
printBinTree(root, 0, sb);
return sb.toString();
}

/**
* 打印二叉樹
* @param btree 根結點
* @param n 結點層數
* @param sb 用於保存記錄的字符串
*/
private void printBinTree(BinTreeNode btree, int n, StringBuilder sb) {
if (null == btree)
return;
printBinTree(btree.getRChild(), n + 1, sb);
for (int i = 0; i < n; i++)
sb.append("\t");
if (n >= 0)
sb.append(btree.getData() + "\n");
printBinTree(btree.getLChild(), n + 1, sb);
}

/**
* 求葉結點的個數
* @return 葉結點的個數
*/
public int sizeLeaf() {
searchLeaf(this.root);
return leafSize;
}
/**
* 葉結點的個數
* @param rt
*/
private void searchLeaf(BinTreeNode rt) {
if (null == rt)
return;
if (rt.isLeaf())
leafSize++;
else {
searchLeaf(rt.getLChild());
searchLeaf(rt.getRChild());
}
}

}


測試

package datastructure.tree.btree;
import java.util.Iterator;

public class BTreeTest2 {
// 測試功能
// 結果：所有功能都能實現，正確
public static void main(String args[]) {
//構造二叉樹
BinTreeNode roots = new BinTreeNode();
BinTreeNode node = new BinTreeNode();
roots.setData(‘A‘);
roots.setLChild(new BinTreeNode(‘B‘));
roots.setRChild(new BinTreeNode(‘C‘));
node = roots.getLChild();
node.setLChild(new BinTreeNode(‘D‘));
node.setRChild(new BinTreeNode(‘E‘));
node = roots.getRChild();
node.setLChild(new BinTreeNode(‘F‘));
BinaryTreeOrder order = new BinaryTreeOrder(roots);
//------遍歷--------
Iterator<BinTreeNode> iter1 = order.preOrder();
System.out.println("前序遍歷：");
printIterator(iter1);

Iterator<BinTreeNode> iter2 = order.inOrder();
System.out.println("中序遍歷：");
printIterator(iter2);

Iterator<BinTreeNode> iter3 = order.postOrder();
System.out.println("後序遍歷：");
printIterator(iter3);

Iterator<BinTreeNode> iter4 = order.levelOrder();
System.out.println("層次遍歷：");
printIterator(iter4);

String str = order.printBinTree();
System.out.println("打印二叉樹：\n" + str);
System.out.println("葉結點的個數：" + order.sizeLeaf());
BinTreeNode nodeone = order.find(‘E‘);
System.out.println("根結點的數據元素：" + nodeone.getData());
}
public static void printIterator(Iterator<BinTreeNode> iter) {
while(iter.hasNext()) {
System.out.print("\t" + iter.next().getData());
}
System.out.println();
}

}

結果：
前序遍歷：
A BD
E C F
中序遍歷：
D BE
A F C
後序遍歷：
D EB
F C A
層次遍歷：
A BC
D E F
打印二叉樹：
C
F
A
E
B
D

葉結點的個數：3
根結點的數據元素：E

轉載至：http://blog.csdn.net/luoweifu/article/details/9089551

java數據結構之三叉鏈表示的二叉樹

相關推薦

java數據結構之三叉鏈表示的二叉樹

按層遍歷 postorder while ldl 字符串 param pub link 根節點 三叉鏈表示的二叉樹定義所畏的三叉鏈表示是指二叉樹由指向左孩子結點、右孩子結點、父親結點【三叉】的引用（指針）數據和數據組成。 package datastructure.t

【數據結構與算法】二叉樹遞歸與非遞歸遍歷（附完整源碼）(轉）

style stack gravity text 一個 eat 遞歸遍歷 deb 雙向 轉自：http://blog.csdn.net/ns_code/article/details/12977901 二叉樹是一種非常重要的數據結構，很多其他數據機構都是基於二叉樹的基礎

數據結構（十四）——二叉樹

數據結構 二叉樹數據結構（十四）——二叉樹 一、二叉樹簡介 1、二叉樹簡介 二叉樹是由n（n>=0）個結點組成的有序集合，集合或者為空，或者是由一個根節點加上兩棵分別稱為左子樹和右子樹的、互不相交的二叉樹組成。二叉樹的五種形態： 2、二叉樹的存儲結構模型 樹的另一種表示法：孩子兄弟表示法A、每個結點都有

數據結構實現（三）二叉樹

.data lis 父節點 集合 結構 ron 進棧 nod 建立 轉載：http://www.cnblogs.com/CherishFX/p/4617105.html 二叉樹( Binary Tree) 是 n(n>=0)個結點的有限集合，該集合或者為空集(稱為空二

【數據結構與算法】二叉樹——哈夫曼編碼

個人 分享 recode sort 遞歸 運用 數據結構 light 什麽是 最近有很多的小朋友問我什麽是哈夫曼編碼，哈夫曼編碼是一種可變字長的編碼，那什麽是可變字長呢？就是一句話裏的每一個字符(ASCII碼)它的位數(長度)是不一樣的。就像我們一句話(AAAACCCCCD

1291=數據結構上機測試4.1:二叉樹的遍歷與應用1

style nod bsp left turn 二叉 reat 中序遍歷 alloc 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 char

數據結構【查找】—二叉樹排序以及查找

數據 存在 binary 結點 ear style define 中間 color 講解： 　　總結一句話： 　　　　小的左邊，大的放右邊。 　　特點：　　　　 　　　　二叉排序樹（Binary Sort Tree），又稱為二叉查找樹。它或者是一棵空樹，或者是具有下

Java數據結構之LinkedList、ArrayList的效率分析

Java 前言： 在我們平常開發中難免會用到List集合來存儲數據，一般都會選擇ArrayList和LinkedList，以前只是大致知道ArrayList查詢效率高LinkedList插入刪除效率高，今天來實測一下。 先了解一下List

數據結構之－鏈表、棧的實現及題目

mem nod 習題 cell class find sla turn creat GitHub : https://github.com/hanxloop/c_dev_library 前幾天碼了鏈表和棧，棧有數組實現和鏈表實現，自己跑了書上的示例，能跑的通，開心，接口、

JAVA數據結構--LinkedList雙向鏈表

expected pty div expect ise tee override 另一個 lock 鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態

java數據結構：雙向鏈表

分享圖片 nodevalue next args 新增 data over bre print 雙向鏈表與單鏈表區別在於他多了一個鏈域，用來存放前驅節點。 基本方法實現： 新增節點： 當前節點的next為新增節點，新增節點的next為當前節點的next.next新增節點

Java數據結構之數組

java 數據結構 數組 自定義數組(面向對象編程)：直接上代碼：package com.xingej.algorithm.datastructure.array; /** * 面向對象編程 * * 自定義類數組 * * 你一定要明白，這是在JDK基礎之上的封裝，要學會這種思路，其

Java數據結構之棧

java 數據結構 棧 package com.xingej.algorithm.datastructure.stack; /** * 數據結構之棧Stack * * 以long類型為測試用例 * * @author erjun 2017年12月4日 下午10:22:34 */

Java數據結構之單鏈表

java 數據結構 單鏈表 鏈表的組成：鏈表頭+結點? ?鏈表頭一般只存儲下一個節點的引用? ?節點：存數據+下一個節點的引用鏈表頭代碼：package?com.xingej.algorithm.datastructure.linkedList.singleLinkedList; /** ?*?

java數據結構之CopyOnWriteArrayList和CopyOnWriteArraySet

行操作 bounds nwr 使用 lin clas 實例 cloneabl 什麽是 一、什麽是CopyOnWrite 　　CopyOnWrite（寫時復制）簡稱COW，這是一種利用讀寫分離的思想來實現線程安全的程序設計思路。顧名思義該思想就是在寫的時候將原數據復制一份，

java數據結構之WeakHashMap

== must hash 回收 clas iter 父類 構造 help 一、JAVA中的四種引用類型 　　1、強引用（StrongReference）：強引用是最為普遍的一種引用，如果對象被強引用，那麽垃圾回收器無論如何都不會回收它，當內存不足時會拋出OutOfMemo

Java數據結構和算法（二）——數組

image 創建 函數 編程 局限性 總結 遍歷數組 ron 添加 　　上篇博客我們簡單介紹了數據結構和算法的概念，對此模糊很正常，後面會慢慢通過具體的實例來介紹。本篇博客我們介紹數據結構的鼻祖——數組，可以說數組幾乎能表示一切的數據結構，在每一門編

數據結構實現（四）二叉查找樹java實現

.com ML treenode 設置 AC getparent 邏輯圖 技術分享 ldb 轉載 http://www.cnblogs.com/CherishFX/p/4625382.html 二叉查找樹的定義： 　　二叉查找樹或者是一顆空樹，或者是一顆具有以下特性的非空二

數據結構與算法問題 二叉搜索樹

它的 ng- type i++ 刪掉 簡單 font 數據結構與算法 -a 1、序 具體實現了二叉查找樹的各種操作：插入結點、構造二叉樹、刪除結點、查找、 查找最大值、查找最小值、查找指定結點的前驅和後繼 2、二叉查找樹簡單介紹 它或者是一棵空樹；

數據結構與算法問題 二叉排序樹

geo post adding ng- spa main 排序樹 ack word 題目描寫敘述： 二叉排序樹，也稱為二叉查找樹。能夠是一顆空樹。也能夠是一顆具有例如以下特性的非空二叉樹： 1. 若左子樹非空，則左