此处包括一个泛型二叉树抽象类,一个Integer型实现类,一个测试类。
实现了二叉树的以下功能:
1.先序遍历
2.中序遍历
3.后序遍历
4.求高度
5.求节点总数
6.取指定节点的双亲节点
7.删除指定节点
8.判空
9.清空二叉树
泛型二叉树抽象类
BinaryTree.java:
package binarytree;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;
public abstract class BinaryTree<T> {
Node<T> root;
protected int size = 0;
public BinaryTree() {
this.root = new Node<T>();
}
public BinaryTree(T data) {
this.root = new Node<T>(data);
}
public BinaryTree(Node<T> root) {
this.root = root;
}
public void preOrderTraverse() {
System.out.println("pre-order traverse: ");
preOrderTraverse(this.root);
System.out.println();
}
public void preOrderTraverse(Node<T> root) {
if(root == null) {
return;
}
visit(root);
preOrderTraverse(root.left);
preOrderTraverse(root.right);
}
public void inOrderTraverse() {
System.out.println("in-order traverse: ");
inOrderTraverse(this.root);
System.out.println();
}
public void inOrderTraverse(Node<T> root) {
if(root == null) {
return;
}
inOrderTraverse(root.left);
visit(root);
inOrderTraverse(root.right);
}
public void postOrderTraverse() {
System.out.println("post-order traverse: ");
postOrderTraverse(this.root);
System.out.println();
}
public void postOrderTraverse(Node<T> root) {
if(root == null) {
return;
}
postOrderTraverse(root.left);
postOrderTraverse(root.right);
visit(root);
}
public void levelTraverse() {
System.out.println("level traverse: ");
Queue<Node<T>> q = new LinkedBlockingQueue<Node<T>>();
q.add(root);
Node<T> node = new Node<T>();
while(q.isEmpty() != true) {
node = q.poll();
visit(node);
if(node.left != null) {
q.add(node.left);
}
if(node.right != null) {
q.add(node.right);
}
}
System.out.println();
}
public Node<T> getParent(Node<T> node){
return (node == null || node == this.root) ?
null : getParent(this.root, node);
}
public Node<T> getParent(Node<T> root, Node<T> node){
if(root == null || node == null || root == node || node == this.root) {
return null;
}
if(root.left == node || root.right == node) {
return root;
}
if(getParent(root.left, node) != null) {
return getParent(root.left, node);
}
return getParent(root.right, node);
}
public void delete(Node<T> node) {
Node<T> parent = getParent(node);
if(parent.left == node) {
parent.left = null;
}
if(parent.right == node) {
parent.right = null;
}
}
public void getHeight() {
System.out.print("the height is: ");
System.out.println(getHeight(this.root));
}
public int getHeight(Node<T> root) {
if(root == null) {
return 0;
}
int l = getHeight(root.left);
int r = getHeight(root.right);
return l > r ? l + 1 : r + 1;
}
public void getSize() {
this.size = 0;
System.out.print("the size is: ");
getSize(this.root);
System.out.println(this.size);
}
public void getSize(Node<T> root) {
if(root == null) {
return;
}
size++;
getSize(root.left);
getSize(root.right);
}
public void deleteBinaryTree() {
this.root = null;
}
public boolean isEmpty() {
return this.root == null;
}
public abstract void visit(Node<T> node);
}
Character型实现类
CharacterBinaryTree.java:
package binarytree;
public class CharacterBinaryTree extends BinaryTree<Character> {
public CharacterBinaryTree() {
super();
}
public CharacterBinaryTree(Character data) {
super(data);
}
public CharacterBinaryTree(Node<Character> root) {
super(root);
}
@Override
public void visit(Node<Character> node) {
System.out.print(node.data);
}
}
测试类
CharacterBinaryTreeDemo.java:
package binarytree;
public class CharacterBinaryTreeDemo {
public static void main(String[] args) {
Node<Character> nodeA = new Node<Character>('A');
Node<Character> nodeB = new Node<Character>('B');
Node<Character> nodeC = new Node<Character>('C');
Node<Character> nodeD = new Node<Character>('D');
Node<Character> nodeE = new Node<Character>('E');
Node<Character> nodeF = new Node<Character>('F');
Node<Character> nodeG = new Node<Character>('G');
Node<Character> nodeH = new Node<Character>('H');
Node<Character> nodeI = new Node<Character>('I');
nodeA.setLeft(nodeB);
nodeA.setRight(nodeG);
nodeB.setLeft(nodeC);
nodeB.setRight(nodeD);
nodeD.setLeft(nodeE);
nodeD.setRight(nodeF);
nodeG.setLeft(nodeH);
nodeH.setRight(nodeI);
CharacterBinaryTree test = new CharacterBinaryTree(nodeA);
test.preOrderTraverse();
System.out.println("================");
test.inOrderTraverse();
System.out.println("================");
test.postOrderTraverse();
System.out.println("================");
test.levelTraverse();
System.out.println("================");
test.getSize();
test.getHeight();
System.out.println("================");
test.visit(test.getParent(nodeE));
System.out.println();
test.visit(test.getParent(nodeI));
System.out.println();
System.out.println("================");
test.delete(nodeD);
test.preOrderTraverse();
test.getSize();
test.getHeight();
System.out.println("================");
test.delete(nodeI);
test.preOrderTraverse();
test.getSize();
test.getHeight();
System.out.println("================");
}
}
输出结果:
pre-order traverse:
ABCDEFGHI
================
in-order traverse:
CBEDFAHIG
================
post-order traverse:
CEFDBIHGA
================
level traverse:
ABGCDHEFI
================
the size is: 9
the height is: 4
================
D
H
================
pre-order traverse:
ABCGHI
the size is: 6
the height is: 4
================
pre-order traverse:
ABCGH
the size is: 5
the height is: 3
================