java建立二分搜索树
今天，我在这里跟大家分享一下java建立二分搜索树。
我先分享一个关于二分搜索树的文章 二分搜索树详解，这位博主主要介绍了二分搜索树的构建原理(增，删，改，查)。如果不理解二分搜索树的朋友可以先去看一下。我相信，认真理解完，一定会有收获。
重点来了：下面我就分享一下java构建二分搜索树
接口类：
public interface BST >{
//值的个数
public int size();
//是否为空
public boolean isEmpty();
//加入值
public void add(E e);
//是否包含某值
public boolean contains(E e);
//前序遍历
public void preOrder();
//中序遍历
public void inOrder();
//后序遍历
public void postOrder();
//层序遍历
public void levelOrder();
//得到最大值
public E getMax();
//得到最小值
public E getMin();
//删除最小值
public E removeMin();
//删除最大值
public E removeMax();
//删除特定的值
public void remove(E e);
}
实现类：
public class BST1 >implements BST{
private int size;//长度
private Node root;//根节点
private class Node{
public E e;
public Node right,left;
public Node(E e){
this.e=e;
right=null;
left=null;
}
}
public BST1(){
root=null;
size=0;
}
//得到树的长度（值的个数：值不重复）
@Override
public int size() {
return size;
}
//判断树是否为空
@Override
public boolean isEmpty() {
return size==0;
}
//向二分搜索树中增加值
@Override
public void add(E e) {
if(root==null){
root=new Node(e);
size++;
}else{
add(root,e);
}
}
private void add(Node node,E e){
//说明存在该值
if(e.equals(node.e)) {
return;
}else if(node.left==null&&node.e.compareTo(e)>0){
node.left=new Node(e);
size++;
return ;
}else if(node.right==null&&node.e.compareTo(e)<0){
node.right=new Node(e);
size++;
return ;
}
if(node.e.compareTo(e)>0){
add(node.left,e);
}
if(node.e.compareTo(e)<0){
add(node.right,e);
}
}
@Override
public boolean contains(E e) {
return contains(root,e);
}
private boolean contains(Node node,E e){
if(node==null){
return false;
}
if(node.e.compareTo(e)==0){
return true;
}else if(node.e.compareTo(e)>0){
return contains(node.left,e);
}else{
return contains(node.right,e);
}
}
//前序
@Override
public void preOrder() {
if(root==null){
throw new IllegalArgumentException("树为空，无法遍历");
}
preOrder(root);
}
private void preOrder(Node node){
if(node==null){
return ;
}
System.out.print(node.e+" ");
preOrder(node.left);
preOrder(node.right);
}
//中序遍历
@Override
public void inOrder() {
if(root==null){
throw new IllegalArgumentException("树为空，无法遍历");
}
inOrder(root);
}
private void inOrder(Node node){
if(node==null){
return ;
}
preOrder(node.left);
System.out.print(node.e+" ");
preOrder(node.right);
}
//后序遍历
@Override
public void postOrder() {
if(root==null){
throw new IllegalArgumentException("树为空，无法遍历");
}
postOrder(root);
}
private void postOrder(Node node){
if(node==null){
return ;
}
preOrder(node.left);
preOrder(node.right);
System.out.print(node.e+" ");
}
//层序遍历
@Override
public void levelOrder() {
if(root==null){
throw new IllegalArgumentException("树为空，无法遍历");
}
//利用队列进行实现
Queue queue=new LinkedList();
queue.add(root);
while(!queue.isEmpty()){
Node removeNode = (Node)queue.remove();
System.out.print(" "+removeNode.e);
if(removeNode.left!=null){
((LinkedList) queue).add(removeNode.left);
}
if(removeNode.right!=null){
((LinkedList) queue).add(removeNode.right);
}
}
}
//获取最大值
@Override
public E getMax() {
if(size==0){
throw new IllegalArgumentException("树为空，无最大值");
}
return getMax(root).e;
}
private Node getMax(Node node){
while(node.right!=null){
node=node.right;
}
return node;
}
@Override
public E getMin() {
if(size==0){
throw new IllegalArgumentException("树为空，无最小值");
}
return getMin(root).e;
}
private Node getMin(Node node){
/*while(node.left!=null){
node=node.left;
}
return node;
*/
if(node.left==null){
return node;
}
return getMin(node.left);
}
//删除最小值
@Override
public E removeMin(){
//先得到最小值的结点
Node minNode = getMin(root);
E data=minNode.e;
//执行删除的操作
root=removeMin(root);
return data;
}
private Node removeMin(Node node){
if(node.left==null){
Node rightNode=node.right;
size--;
return rightNode;
}
node.left=removeMin(node.left);
return node;
}
//删除最大值
@Override
public E removeMax() {
Node maxNode = getMax(root);
E data=maxNode.e;
root=removeMax(root);
return data;
}
private Node removeMax(Node node){
if(node.right==null){
Node leftNode=node.left;
size--;
return leftNode;
}
node.right=removeMax(node.right);
return node;
}
//删除特定值
@Override
public void remove(E e) {
root=remove(e,root);
}
private Node remove(E e,Node node){
if(node==null) {
return null;
}
if(e.compareTo(node.e)<0) {//向左树走
node.left=remove(e,node.left);
return node;
}else if(e.compareTo(node.e)>0){//向右树走
node.right=remove(e,node.right);
return node;
}else{//表名是找到想要删除的值了
//这里执行删除三种情况的节点
if(node.left==null){
Node rightNode=node.right;
node.right=null;
size--;
return rightNode;
}
if(node.right==null) {
Node leftNode = node.left;
node.left = null;
size--;
return leftNode;
}
Node tempNode=getMin(node.right);
tempNode.right=removeMin(node.right);
tempNode.left=node.left;
node.left=null;
node.right=null;
return tempNode;
}
}
//传入数组创建二分搜索树
public void createTree(E[] arrys){
if(arrys.length==0){
throw new IllegalArgumentException("创建失败！数不能为空");
}
for (int i = 0; i 测试类：
public class Main{
public static void main(String[] args) {
BST1 bst=new BST1();
Integer[] arrays={5,3,7,1,4,6};
//创建二分搜索树
bst.createTree(arrays);
System.out.println("前序遍历结果为:");
bst.preOrder();
System.out.println("\n中序遍历结果为");
bst.inOrder();
System.out.println("\n后序遍历结果为");
bst.postOrder();
System.out.println("\n层序遍历结果为");
bst.levelOrder();
System.out.println("\n后序遍历结果为");
System.out.println("\n最小值为："+bst.getMin());
System.out.println("\n最大值为："+bst.getMax());
}
} 测试结果：
里面还有其他的方法，就需要读者自行测试了。今天就分享到这里了，大家加油！！！