# 二叉树——Java实现

package struct;

interface Tree{
//插入元素
void insert(int value);
//中序遍历
void inOrder();
//先序遍历
void perOrder();
//后序遍历
void postOrder();
//层序遍历
//void levelOrder();
//求最小值
int getMinValue();
//求最小值
int getMaxValue();
//指定元素删除
boolean delete(int value);
//求元素个数
int length();
//求树的高度
int height();
}

//工厂类
class Factory1{
//构造函数
private Factory1(){}
public static Tree getTreeInstance(){
return new BinaryTreeImpl();
}
}

class BinaryTreeImpl implements Tree{
//根节点
private Node root;
private int size;
class Node{
//定义左子树
private Node leftChild;
//定义右子树
private Node rightChild;
private int data;
//以下为构造方法
public Node(int data){
this.data = data;
}
public Node(Node leftChild, Node rightChild, int data) {
super();
this.leftChild = leftChild;
this.rightChild = rightChild;
this.data = data;
}
}

//插入元素
public void insert(int data) {
Node node = new Node(data);
//空树
if(root == null){
root = node;
root.leftChild = null;
root.rightChild = null;
size++;
}else{
//非空树
Node current = root;
Node parent = null;
while(true){
if(data < current.data){
parent = current;
current = parent.leftChild;
//当前元素小于根节点,当前节点为空
if(current == null){
parent.leftChild = node;
size++;
break;
}
}else if(data > current.data){
parent = current;
current = parent.rightChild;
//当前元素大于根节点，且当前节点为空，否则继续循环使当前的current为根节点
if(current == null){
parent.rightChild = node;
size++;
break;
}
}else{
System.out.println("have same data in the binary tree;");
}
}//end of  while
}
}
//中序遍历
public void inOrder() {
System.out.println("中序遍历：");
inOrder1(root);
System.out.println();
}
//中序遍历递归函数
private void inOrder1(Node node){
if( node == null){
return;
}
inOrder1(node.leftChild);
display(node);
inOrder1(node.rightChild);
}

//打印函数
private void display(Node node){
System.out.print(node.data+" ");
}

//前序遍历
public void perOrder() {
System.out.println("前序遍历：");
perOrder1(root);
System.out.println();
}
//前序遍历递归函数
private void perOrder1(Node node){
if(node == null){
return;
}
display(node);
perOrder1(node.leftChild);
perOrder1(node.rightChild);
}

//后序遍历
public void postOrder() {
System.out.println("后序遍历：");
postOrder1(root);
System.out.println();
}
//后续遍历递归函数
private void postOrder1(Node node){
if(node == null){
return;
}
postOrder1(node.leftChild);
postOrder1(node.rightChild);
display(node);
}
//层序遍历
/*
public void levelOrder() {
}
*/
//求取树中元素最小值
public int getMinValue() {
Node node = root;
//空树无最小元素
if(root == null){
return -1;
}
Node current = node.leftChild;
while(true){
if(current.leftChild == null){
return current.data;
}
current = current.leftChild;
}
}
//求树中最大元素
public int getMaxValue(){
Node node = root;
if(node == null){
return -1;
}
Node current = node.rightChild;
while(true){
if(current.rightChild == null){
return current.data;
}
current = current.rightChild;
}
}
//删除树中元素
public boolean delete(int value) {
return false;
}
//求树中元素个数
public int length(){
return size;
}
//求树的高度
public int height(){
if(root == null){
return 0;
}
return height1(root);
}
private int height1(Node node) {
if(node!=null){
int lheight = height1(node.leftChild);
int rheight = height1(node.rightChild);
return lheight > rheight ? lheight+1:rheight+1;
}
return 0;
}
}
public class BinaryTree {
public static void main(String[] args) {
Tree tree = Factory1.getTreeInstance();
System.out.println("===============测试insert函数=====================");
tree.insert(2);
tree.insert(1);
tree.insert(5);
tree.insert(20);
tree.insert(3);
tree.insert(7);
tree.insert(0);
tree.insert(10);
System.out.println("\n"+"===============测试length函数====================="+"\n");
System.out.println(tree.length());
System.out.println("\n"+"===============测试inOrder函数====================="+"\n");
tree.inOrder();
System.out.println("\n"+"===============测试perOrder函数====================="+"\n");
tree.perOrder();
System.out.println("\n"+"===============测试postOrder函数====================="+"\n");
tree.postOrder();
System.out.println("\n"+"===============测试getMinValue函数====================="+"\n");
System.out.println(tree.getMinValue());
System.out.println("\n"+"===============测试getMaxValue函数====================="+"\n");
System.out.println(tree.getMaxValue());
System.out.println("\n"+"===============测试height函数====================="+"\n");
System.out.println(tree.height());
}
}