/**
* 二叉查找树
*/
public class BinarySortTreeTest {
// 创建一个节点类 包含值,左节点 右节点
public class Node {
int value;
Node left;
Node right;
public Node() {
}
// 有参构造
public Node(int value) {
this.value = value;
}
// 插入节点
public void add(Node node) {
// 判断传进来的节点是否为空
if (node == null) {
return;
}
// 判断传进来的节点比当前子树的根节点的值大还是小
// 如果小 这进入左边
if (node.value < this.value) {
// 如果左节点为空 那么传进来的节点就为左节点
if (this.left == null) {
this.left = node;
} else {
// 递归在进行判断 ,直到找到为空的节点
this.left.add(node);
}
} else {
// 如果大于根节点就进入右边
// 如果右节点为空,那么传进来的节点就为右节点
if (this.right == null) {
this.right = node;
} else {
// 如果右节点不为空 则递归在进行判断
this.right.add(node);
}
}
}
//中序遍历二叉查找树
//中序指以升序的方式遍历所有节点 先左节点,在根节点,在右节点
public void middleOder(Node node) {
// 如果为空这结束
if (node == null) {
return;
}
/*
先找到最左边的节点 然后输出值 在看其右边是否有值 有则输出
没有就返回此节点的上一个根节点 输出其值,在看其右节点是否有值,有就输出
在返回到此节点的上一个根节点
依次循环
*/
middleOder(node.left);
System.out.println(node.value);
middleOder(node.right);
}
// 查找某一节点 传进来一个值
public Node serch(int value){
// 值相等 就返回此对象
if(this.value == value){
return this;
// 小于就找此节点的左节点 如果左节点为空 表示没找到
}else if(value<this.value){
if(this.left == null){
return null;
}else {
return this.left.serch(value);
}
// 大于就找此节点的右节点 如果右节点为空,表示没找到
}else {
if(this.right ==null){
return null;
}else {
return this.right.serch(value);
}
}
}
// 查找父节点
public Node serchParent(int value){
// 先判断此节点的左右节点是否与传进来的值相等 相等则此节点就是父节点
if((this.left != null && this.left.value==value) || (this.right !=null && this.right.value ==value)){
return this;
} else {
// 此节点如果大于传进来的值,则找左节点 左节点为空,表示没有值与其匹配
if(value < this.value && this.left != null){
return this.left.serchParent(value);
// 此节点如果大于传进来的值,则找左节点 左节点为空,表示没有值与其匹配
}else if(value > this.value && this.right != null){
return this.right.serchParent(value);
}
}
return null;
}
}
//
// 插入数据
// public void insertBST(Key key ,Value val){
// if(key ==null){
//
// }
Node root;
// 向二叉排序树中添加节点
public void add(Node node){
if(root == null){
root=node;
}else {
root.add(node);
}
// System.out.println(root.value);
}
// 查找二叉排序树的所有节点
public void frontShow(){
if(root !=null){
this.root.middleOder(root);
}
}
// 查找单个节点
public Node searchNode(int value){
if(root ==null){
return null;
}else {
return this.root.serch(value);
}
}
// 查找父节点
public Node searchPanertNode(int value){
if (root == null){
return null;
}else {
return this.root.serchParent(value);
}
}
// 删除节点
public void delete(int value){
if(root ==null){
return;
}else {
// 找到此节点,为空则没有
Node target=searchNode(value);
if(target ==null){
return;
}
// 找到此节点的父节点
Node parent = searchPanertNode(value);
// System.out.println(parent.value);
//要删除的节点是叶子结点
if(target.left == null && target.right == null){
if(parent.left.value == value){
// 父节点的子节点改为空才是真的改为空;如把target =null,节点中的值并不会改变
parent.left=null;
}else {
parent.right=null;
}
// target=null;
// Node target1=searchNode(value);
// System.out.println("后来的"+target1.value);
}
//要删除的节点有两个子节点的情况
else if (target.left != null && target.right !=null){
//删除右子树中值最小的节点,并获取到该节点的值
int min=minDelete(target.right);
target.value=min;
}else {
//需要删除的目标节点的左节点不为空
if(target.left != null){
//要删除的子节点是其父节点的左子节点
if(parent.left.value == value){
parent.left=target.left;
}else {
//要删除的子节点是其父节点的右子节点
parent.right=target.right;
}
}else {
//需要删除的目标节点的右节点不为空
if (parent.right!=null){
if(parent.left.value == value){
parent.left=target.left;
}else {
parent.right=target.right;
}
}
}
}
}
}
public int minDelete(Node node){
while (node.left!=null){
node=node.left;
}
delete(node.value);
return node.value;
}
//测试代码
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9};
BinarySortTreeTest binary=new BinarySortTreeTest();
// 添加节点
for (int i : arr) {
// 用有参构造创造节点 调用add加入节点
binary.add(binary.new Node(i));
}
// 遍历二叉查找树
binary.frontShow();
System.out.println("华丽的分割线");
// 删除节点 7
binary.delete(7);
binary.frontShow();
// 查找节点 7
Node node= binary.new Node(7);
Node res= binary.searchNode(node.value);
if(res!=null){
System.out.println(res.value);
}else {
System.out.println("未找到");
}
}
}
积累点滴,做好自己~