定义
一棵空树,或者是具有下列性质的二叉树:
1 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
2) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
3) 左、右子树也分别为二叉排序树;
4) 没有键值相等的结点。
代码实现如下,参考文章的图解和思路都超赞
/**
* 二叉排序树节点
*/
public class BSTreeNode {
/**
* 树的标识
*/
private int key;
/**
* 左子节点
*/
private BSTreeNode leftNode;
/**
* 右子节点
*/
private BSTreeNode rightNode;
public BSTreeNode() {
}
public BSTreeNode(int key) {
this.key = key;
}
public int getKey() {
return key;
}
public void setKey(int key) {
this.key = key;
}
public BSTreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(BSTreeNode leftNode) {
this.leftNode = leftNode;
}
public BSTreeNode getRightNode() {
return rightNode;
}
public void setRightNode(BSTreeNode rightNode) {
this.rightNode = rightNode;
}
@Override
public String toString() {
return "BSTreeNode{" +
"key=" + key +
'}';
}
/**
* 添加子节点
*
* @param node
*/
public void add(BSTreeNode node) {
if (node == null) {
return;
}
if (this.key == node.key) {
System.out.println("该节点已存在");
return;
}
//放在该节点的左边
if (node.key < this.key) {
//如果没有左子节点,那么就放左子节点
if (this.leftNode == null) {
this.leftNode = node;
} else {
//继续递归
this.leftNode.add(node);
}
} else {
//放在该节点的右边
//如果没有右子节点,那么就放右子节点
if (this.rightNode == null) {
this.rightNode = node;
} else {
//继续递归
this.rightNode.add(node);
}
}
}
}
/**
* 二叉排序树(二叉搜索树 BinarySearchTree)
* <p>
* 实现功能
* 1.添加
* 2.查找
* 3.删除
*/
public class BSTree {
/**
* 根节点
*/
private BSTreeNode root;
/**
* 添加节点
*
* @param node
*/
public void add(BSTreeNode node) {
if (root == null) {
root = node;
return;
}
//添加
root.add(node);
}
/**
* 删除节点
*
* @param key
*/
public void delete(int key) {
BSTreeNode parent = searchParent(key);
if (parent == null) {
System.out.println("parent未找到");
return;
}
//找到等待删除的节点
BSTreeNode target;
//跟parent的子节点进行比对
if (parent.getLeftNode() != null && parent.getLeftNode().getKey() == key) {
target = parent.getLeftNode();
} else {
target = parent.getRightNode();
}
System.out.println("key=" + key + "parent=" + parent + "target=" + target);
//那么就有三种情况
//1.待删除节点是叶子节点,那么就直接删
//2.待删除节点下有单个子节点,那么就节点上移
//3.待删除节点下存在两个子节点,那么就把右子节点下最小的值上移
int num = getChildNum(target);
//分别出来三种情况
if (num == 0) {
//进入情况1
//如果是左节点就删除左节点,是右节点就删除右节点
if (target == parent.getLeftNode()) {
parent.setLeftNode(null);
} else {
parent.setRightNode(null);
}
} else if (num == 1) {
//情况2
//如果是左节点就删除左节点的子节点上提,是右节点就上提右子节点的子节点
BSTreeNode child = getSingleChild(target);
if (target == parent.getLeftNode()) {
parent.setLeftNode(child);
} else {
parent.setRightNode(child);
}
} else {
//情况3 ,待删除的子节有两个子节点
//找出右子节点下最小的那个节点,替换到待删除节点
BSTreeNode minChild = getMinChild(target);
//删除该节点
delete(minChild.getKey());
//然后替换,完成
target.setKey(minChild.getKey());
}
}
/**
* 遍历查询子数下最小的节点
*
* @param target
* @return
*/
private BSTreeNode getMinChild(BSTreeNode target) {
BSTreeNode temp = target.getLeftNode();
while (temp.getLeftNode() != null) {
temp = temp.getLeftNode();
}
return temp;
}
/**
* 获取唯一的孩子节点
*
* @param target
* @return
*/
private BSTreeNode getSingleChild(BSTreeNode target) {
//左子节点存在就返回,否则返回右子节点
return target.getLeftNode() != null ? target.getLeftNode() : target.getRightNode();
}
/**
* 获取该节点左右子节点的个数
*
* @param node
* @return
*/
private int getChildNum(BSTreeNode node) {
int num = 0;
//存在左子节点
if (node.getLeftNode() != null) {
num++;
}
//存在右子节点
if (node.getRightNode() != null) {
num++;
}
return num;
}
/**
* 搜索
*
* @param key
* @return
*/
public BSTreeNode search(int key) {
if (null == root) {
return null;
}
BSTreeNode node = root;
while (node != null) {
int match = node.getKey();
if (key == match) {
return node;
}
if (key < match) {
node = node.getLeftNode();
} else {
node = node.getRightNode();
}
}
return null;
}
/**
* 搜索待删除节点的父节点
*
* @param key
* @return
*/
public BSTreeNode searchParent(int key) {
if (null == root) {
return null;
}
BSTreeNode temp = root;
while (temp != null) {
//跟它的子节点进行匹配,匹配任意一个都好使
if ((temp.getLeftNode() != null && temp.getLeftNode().getKey() == key)
|| (temp.getRightNode() != null && temp.getRightNode().getKey() == key)) {
return temp;
}
//不匹配的话,继续查找
int match = temp.getKey();
if (key < match) {
temp = temp.getLeftNode();
} else {
temp = temp.getRightNode();
}
}
return null;
}
/**
* 中序遍历
*/
public void midTraverse() {
if (root == null) {
return;
}
midTraverse(root);
}
/**
* 中序遍历
*
* @param node
*/
private void midTraverse(BSTreeNode node) {
if (node.getLeftNode() != null) {
midTraverse(node.getLeftNode());
}
System.out.println(node);
if (node.getRightNode() != null) {
midTraverse(node.getRightNode());
}
}
}
/**
* 测试代码
* @param args
*/
public static void main(String[] args) {
int[] array = new int[]{50, 30, 80, 20, 35, 34, 32, 40, 70, 75, 100};
BSTree tree = new BSTree();
for (int i = 0; i < array.length; i++) {
int key = array[i];
BSTreeNode node = new BSTreeNode(key);
tree.add(node);
}
System.out.println("中序遍历");
tree.midTraverse();
System.out.println("搜索20=" + tree.search(20));
System.out.println("搜索200=" + tree.search(200));
//删除节点
tree.delete(30);
System.out.println("中序遍历");
tree.midTraverse();
}