数据结构——二叉树（Java实现）_public int getheight(node parent)

此处包括一个泛型二叉树抽象类，一个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
================