java实现二分搜索树BST
package Tree;
import java.awt.image.RescaleOp;
import javax.sound.midi.Soundbank;
/**
* @Title: BST.java
* @Package BinarySerachTree
* @Description: TODO二分搜索树，递归的写法一般具有更高的开销
* @author YEXIN
* @date 2019年8月27日
* @version V1.0
* @Company HUST
*/
/**
*
* @author YEXIN
*二分搜索树必须的类型必须是可比较的，所以E继承Comparable
* @param
*/
public class BST
//节点类，对用户屏蔽
private class Node{
public E e;//节点的存储元素
public Node left,right;//节点的做孩子和右孩子
public Node(E e) {
this.e = e;
left = null;
right = null;
}
}
private Node root;//二分搜索树的根节点
private int size;//二分搜索树的节点个数
public BST() {
root = null;
size = 0;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size==0;
}
/**
* ：递归实现
* 为二分搜索树添加元素,不包含元素
*
*/
//用户调用
public void add(E e) {
root = addToTree(root, e);
}
//对用户隐蔽
//向以node为根节点的二分搜索树插入元素e，递归算法
//因为在比较过程中要插入的二分搜索树在不断变小，所以node每次传入的参数也在改变
private Node addToTree(Node node,E e) {
//终止条件
if (node == null) {
size ++;
return new Node(e);
}
if (e.compareTo(node.e)<0) {
node.left = addToTree(node.left, e);
}else if (e.compareTo(node.e)>0) {
node.right = addToTree(node.right, e);
}
return node;
}
//查询是否包含元素,开放给用户
public boolean contains(E e) {
return contains(root,e);
}
//自己私有的，对用户屏蔽，查看以node为根的二分搜索树是否含有元素e，递归算法
private boolean contains(Node node,E e) {
if (node == null) {
return false;
}
if (e.compareTo(node.e) == 0) {
return true;
}else if (e.compareTo(node.e)>0) {
return contains(node.right,e);
}else //(e.compareTo(node.e)<0) {
return contains(node.left,e);
}
//======================================================
//前序遍历，先访问根，再左子树，再右子树
public void preOrder() {
preOrder(root);
}
//前序遍历以node为根节点的二分搜索树
private void preOrder(Node node) {
if (null == node) {
return;
}
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
//====================================================
//中序遍历
public void inOrder() {
inOrder(root);
}
private void inOrder(Node node) {
if (node == null) {
return;
}
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
//====================================================
//后序遍历,用于内存释放，先遍历左右子树
public void postOrder() {
postOrder(root);
}
private void postOrder(Node node) {
if (node == null) {
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
//====================================================
@Override//直接将对象转为字符串的方法，需要自己实现
public String toString() {
StringBuilder res = new StringBuilder();
grenerateBSTString(root,0,res);
return res.toString();
}
//生成node为根节点，深度为depth的二叉树的字符串
private void grenerateBSTString(Node node,int depth,StringBuilder res) {
if (node == null) {
res.append(getDepthString(depth)+"null\n");
return;//不能省略，作为访问到最后节点时终止操作。
}
res.append(getDepthString(depth)+node.e+"\n");
grenerateBSTString(node.left, depth+1, res);
grenerateBSTString(node.right, depth+1, res);
}
private String getDepthString(int depth) {
StringBuilder res = new StringBuilder();
for (int i = 0; i < depth; i++) {
res.append("--");
}
return res.toString();
}
public static void main(String[] args) {
System.out.println("------BST--------");
BST
int[] arr = {5,3,6,8,4,2};
for (int i : arr) {
bst.add(i);
}
System.out.println("========前序遍历=======");
bst.preOrder();
System.out.println("===============");
System.out.println(bst);
System.out.println("========中序遍历=======");
bst.inOrder();
System.out.println("========后序遍历=======");
bst.postOrder();
}
}
==========================
------BST--------
========前序遍历=======
5
3
2
4
6
8
===============
5
--3
----2
------null
------null
----4
------null
------null
--6
----null
----8
------null
------null
========中序遍历=======
2
3
4
5
6
8
========后序遍历=======
2
4
3
8
6
5