前言
Binary Search Tree,对其中任意一个节点,需要满足左子节点的值小于该节点的值,右子节点的值大于该节点的值。(左小右大)。
其中序遍历为一个升序序列。
下面来实现BST,分别有插入方法(迭代实现以及递归实现)、删除方法、判断树中是否包含某一元素、中序遍历打印BST以及分层遍历打印BST。
具体的 Java 代码如下,可供参考:
代码实现
import java.util.ArrayDeque;
import java.util.Deque;
public class MyBST {
private static class Node{
int val;
Node left,right;
Node(int v){
val=v;
}
}
private Node root;
private int size;
MyBST(){};
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
/**
*
* @param v 在此树中插入 值为 v 的节点
*/
public void insert1(int v){ // 迭代实现
size++;
if(root==null)
root=new Node(v);
else{
Node tmp=root,parent=root;// 需要采用 parent 来标记该插入新元素的位置
while(tmp!=null){
parent=tmp;
if(v>tmp.val)
tmp=tmp.right;
else
tmp=tmp.left;
}
if(v< parent.val)
parent.left=new Node(v);
else
parent.right=new Node(v);
}
}
/**
*
* @param v 在此树中插入 值为 v 的节点
*/
public void insert2(int v){// 递归实现
root= insertInRoot(root,v);
size++;
}
private Node insertInRoot(Node cur, int v){
//递归是 通过采用后序遍历来进行插入的
if(cur==null)
return new Node(v);
if(v>cur.val)
cur.right= insertInRoot(cur.right,v);
else
cur.left= insertInRoot(cur.left,v);
return cur;
}
/**
*
* @param v 查找是否含有值为 v 的节点。
* @return true: 存在 false: 不存在
*/
public boolean contains(int v){
return containsInRoot(root,v);
}
private boolean containsInRoot(Node cur,int v){
if(cur==null)
return false;
else if(v>cur.val)
return containsInRoot(cur.right,v);
else if(v<cur.val)
return containsInRoot(cur.left,v);
return true;
}
/**
*
* @param v 删除值为 v 的节点
* @return 如果此树中不包含 v,返回 false; 否则 删除值为 v 的节点,返回true
*/
public boolean remove(int v){
if(!contains(v))
return false;
root=removeInRoot(root,v);
size--;
return true;
}
private Node removeInRoot(Node cur,int v){
if(cur.val==v){
if(cur.left==null)
return cur.right;
if(cur.right==null)
return cur.left;
//下面代码找到左子树中的最大值 max,然后将其赋值给 cur.val。
//然后在左子树中删除值为 max 的节点。
Node tmp=cur.left;
int max=tmp.val;
while(tmp.right!=null){
max=tmp.right.val;
tmp=tmp.right;
}
cur.val=max;
cur.left=removeInRoot(cur.left,max);
return cur;
}
else if(v>cur.val)
cur.right=removeInRoot(cur.right,v);
else
cur.left=removeInRoot(cur.left,v);
return cur;
}
public void printInOrder(){ // 中序遍历打印 BST
System.out.println("中序遍历:");
inOrder(root);
System.out.println();
}
public void printLayer(){ // 分层遍历打印 BST
System.out.println("分层打印:");
layer(root);
}
private void inOrder(Node cur){
if(cur==null)
return;
inOrder(cur.left);
System.out.print(cur.val+" ");
inOrder(cur.right);
}
private void layer(Node cur){
Deque<Node> q=new ArrayDeque<>();
if(cur==null)
return;
q.offer(cur);
while(!q.isEmpty()){
int count=q.size();
while(count!=0){
Node tmp=q.poll();
System.out.print(tmp.val+" ");
if(tmp.left!=null)
q.offer(tmp.left);
if(tmp.right!=null)
q.offer(tmp.right);
count--;
}
System.out.println();
}
}
public static void main(String[] args) {
MyBST bst=new MyBST();
bst.insert2(2);
bst.insert2(4);
bst.insert2(8);
bst.insert2(1);
bst.insert2(7);
bst.insert2(3);
bst.printInOrder();
// bst.printLayer();
System.out.println(bst.size());
bst.remove(3);
bst.printInOrder();
// bst.printLayer();
bst.remove(1);
bst.printInOrder();
// bst.printLayer();
System.out.println(bst.size());
}
}
总结
完