需求:
提供一个数组{7,3,10,12,5,1,9} 要求能够高效的完成对数据的查询与添加
- 数组:查询快速,但是添加删除性能差
- 链表:查询慢,但是添加删除快速
- 二叉排序树(BST):查询和添加删除操作速度都很快
创建二叉排序树:
- 实现add添加方法
- 若添加的节点为null 直接返回
- 若添加节点小于比较的节点 在左子树,若左节点为空 直接赋值,若左子节点不为空,需要再判断与该左子节点的大小
递归添加
- 实现createTree方法,遍历传入数组所有元素,挨个调用add方法添加节点,实现一颗二叉排序树的创建
代码:
private node root; // 根节点
public void init(node node){ // 初始化root节点
if (node!=null)
root = node;
}
// 根据数组创建二叉排序树
public void createTree(int[] array){
int index = 0;
if (root==null){
System.out.println("root未初始化!现选取第一个元素初始化root");
this.init(new node(array[0]));
index = 1;
}
node node = null;
for(int i=index;i<array.length;i++){ // 遍历array数组 创建二叉排序树
node= new node(array[i]);
addNode(root,node);
}
}
// 添加新节点到二叉排序树
public void addNode(node beginNode,node node){
if (node.getValue() <= beginNode.getValue()){
if (beginNode.getLeft() == null) {
beginNode.setLeft(node);
return;
}
addNode(beginNode.getLeft(),node);
}else {
if (beginNode.getRight() == null){
beginNode.setRight(node);
return;
}
addNode(beginNode.getRight(),node);
}
}
查询树的节点:
// 在二叉排序树内查询指定节点
public node searchNode(int value){
if (root!=null)
root.search(value);
System.out.println("root未初始化!");
return null;
}
// 在二叉树查询指定节点的父节点
public node searchParent(int value){
if (root.getValue() == value) // 如果查询节点为根节点 那么返回null
return null;
return root.searchParent(value);
}
遍历二叉排序树:
// 前序遍历二叉排序树
public void preOrder(node node){
if (node == null){
System.out.println("node节点未初始化!");
return;
}
node.preOrder();
}
// 前序遍历的无参重载
public void preOrder(){
System.out.println("前序遍历:");
this.preOrder(root);
}
删除节点:
思路:
根据删除节点的不同,可以将删除节点分为三类节点来分别讨论
1.叶子节点 2.只有一颗子树的节点 3.有两颗子树的节点
①叶子节点的删除
- 先遍历二叉排序树找到该节点delNode
- 再找到该节点的父节点parentNode(需要判别parentNode为空的情况,即delNode为root节点时的情况)
- 若delNode是parentNode的左子节点 parentNode.left = null 反之为parentNode.right = null
②有两颗子树的节点的删除
- 从targetNode的右子树内找到一个最小节点,记录保存该节点的值到一个临时变量temp内,然后删除该最小节点 将target节点的值赋值给targetNode节点
(为什么要去右子树找最小节点,因为二叉排序树的特性 每一个节点的左子树都小于targetNode节点 右子树都大于targetNode节点 右子树的最小一个节点如果替换后刚好满足都大于左子树全部节点,都小于右子树最小节点 || 按照该思路,其实选取左子树最大的一个节点也可以实现该目标哦)可以以很小的代价实现带子树节点的删除
③只有一颗子树的节点的删除
- 先遍历二叉排序树找到该节点delNode
- 再找到该节点的父节点parentNode(需要判别parentNode为空的情况,即delNode为root节点时的情况)
- 若delNode是parentNode的左子节点 parent.left = delNode.left / right
- 若delNode是parentNode的右子节点 parent.right = delNode.left / right
代码:
// 删除节点
public void delNode(int value){
if (root == null){
System.out.println("root未初始化!");
return;
}
node delNode = root.search(value);
node parentNode = root.searchParent(value);
if (delNode == null){
System.out.println("无此节点,删除失败!");
return;
}
// 如果删除节点是叶子节点
if (delNode.getLeft()==null && delNode.getRight() == null) {
// 1.如果是根节点 直接删除
if (value == root.getValue() && root.getLeft() == null && root.getRight() == null) {
root = null;
return;
}
// 2.如果parentNode不为空 修改parentNode左右指针为null
if (parentNode != null && parentNode.getLeft() == delNode) {
parentNode.setLeft(null);
return;
}
if (parentNode != null && parentNode.getRight() == delNode)
parentNode.setRight(null);
}else if (delNode.getLeft()!=null && delNode.getRight()!=null){ // 如果删除节点是有两颗子树的节点
int minValue = delNode.getRight().findMinValue();
delNode(minValue);
delNode.setValue(minValue);
}else { // 如果删除节点是有一颗子树的节点
if (parentNode!=null){
if (parentNode.getLeft() == delNode) { // 如果删除节点是parent的左子节点
// 如果delNode子节点为左节点赋左节点给Parent 有右节点赋值给parent
parentNode.setLeft((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
}else if (parentNode.getRight() == delNode){ // 如果删除节点是parent的右子节点
parentNode.setRight((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
}
}else { // parent == null说明删除节点是根节点
root = (delNode.getLeft()!=null)?delNode.getLeft() : delNode.getRight();
}
}
}
完整代码与实例:
import javax.xml.soap.Node;
class node{
private int value;
private node left;
private node right;
public node(int value){
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public node getLeft() {
return left;
}
public void setLeft(node left) {
this.left = left;
}
public node getRight() {
return right;
}
public void setRight(node right) {
this.right = right;
}
@Override
public String toString() {
return "value: "+value;
}
// 前序遍历
public void preOrder(){
System.out.println(this);
if (this.left!=null)
this.left.preOrder();
if (this.right!=null)
this.right.preOrder();
}
// 查询节点
public node search(int value){
if (this.value == value)
return this;
if (value < this.value){
if (this.left == null)
return null;
return this.left.search(value);
}
if (this.right == null)
return null;
return this.right.search(value);
}
// 查询父节点
public node searchParent(int value){
// 1.判断当前节点是否就是要删除节点的父节点
if ((this.left != null&& this.left.value == value)
|| (this.right!=null&&this.right.value==value))
return this;
// 2.查找的值小于当前节点并且当前左节点不为空 左子树递归
if (value < this.value && this.left!=null)
return this.left.searchParent(value);
// 3.查找的值大于当前节点并且当前右节点不为空 右子树递归
if (value > this.value && this.right!=null)
return this.right.searchParent(value);
// 4.什么都找不到 返回null
return null;
}
// 返回子树内最小值
public int findMinValue(int min){
min = Math.min(min,this.value);
if (this.left == null && this.right == null)
return Math.min(min, this.value);
if (this.left!=null){
return Math.min(min,this.left.findMinValue(min));
}
return Math.min(min,this.right.findMinValue(min));
}
// 重载 findMinValue方法
public int findMinValue(){
return this.findMinValue(this.value);
}
}
public class binarySortTreeDemo {
private node root; // 根节点
public void init(node node){ // 初始化root节点
if (node!=null)
root = node;
}
// 前序遍历二叉排序树
public void preOrder(node node){
if (node == null){
System.out.println("node节点未初始化!");
return;
}
node.preOrder();
}
// 前序遍历的无参重载
public void preOrder(){
System.out.println("前序遍历:");
this.preOrder(root);
}
// 根据数组创建二叉排序树
public void createTree(int[] array){
int index = 0;
if (root==null){
System.out.println("root未初始化!现选取第一个元素初始化root");
this.init(new node(array[0]));
index = 1;
}
node node = null;
for(int i=index;i<array.length;i++){ // 遍历array数组 创建二叉排序树
node= new node(array[i]);
addNode(root,node);
}
}
// 添加新节点到二叉排序树
public void addNode(node beginNode,node node){
if (node.getValue() <= beginNode.getValue()){
if (beginNode.getLeft() == null) {
beginNode.setLeft(node);
return;
}
addNode(beginNode.getLeft(),node);
}else {
if (beginNode.getRight() == null){
beginNode.setRight(node);
return;
}
addNode(beginNode.getRight(),node);
}
}
// 在二叉排序树内查询指定节点
public node searchNode(int value){
if (root!=null)
root.search(value);
System.out.println("root未初始化!");
return null;
}
// 在二叉树查询指定节点的父节点
public node searchParent(int value){
if (root.getValue() == value) // 如果查询节点为根节点 那么返回null
return null;
return root.searchParent(value);
}
// 删除节点
public void delNode(int value){
if (root == null){
System.out.println("root未初始化!");
return;
}
node delNode = root.search(value);
node parentNode = root.searchParent(value);
if (delNode == null){
System.out.println("无此节点,删除失败!");
return;
}
// 如果删除节点是叶子节点
if (delNode.getLeft()==null && delNode.getRight() == null) {
// 1.如果是根节点 直接删除
if (value == root.getValue() && root.getLeft() == null && root.getRight() == null) {
root = null;
return;
}
// 2.如果parentNode不为空 修改parentNode左右指针为null
if (parentNode != null && parentNode.getLeft() == delNode) {
parentNode.setLeft(null);
return;
}
if (parentNode != null && parentNode.getRight() == delNode)
parentNode.setRight(null);
}else if (delNode.getLeft()!=null && delNode.getRight()!=null){ // 如果删除节点是有两颗子树的节点
int minValue = delNode.getRight().findMinValue();
delNode(minValue);
delNode.setValue(minValue);
}else { // 如果删除节点是有一颗子树的节点
if (parentNode!=null){
if (parentNode.getLeft() == delNode) { // 如果删除节点是parent的左子节点
// 如果delNode子节点为左节点赋左节点给Parent 有右节点赋值给parent
parentNode.setLeft((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
}else if (parentNode.getRight() == delNode){ // 如果删除节点是parent的右子节点
parentNode.setRight((delNode.getLeft()!=null)?delNode.getLeft():delNode.getRight());
}
}else { // parent == null说明删除节点是根节点
root = (delNode.getLeft()!=null)?delNode.getLeft() : delNode.getRight();
}
}
}
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9,2};
binarySortTreeDemo binarySortTreeDemo = new binarySortTreeDemo();
binarySortTreeDemo.createTree(arr);
binarySortTreeDemo.root.preOrder();
binarySortTreeDemo.delNode(1);
binarySortTreeDemo.delNode(7);
binarySortTreeDemo.preOrder();
binarySortTreeDemo.delNode(3);
binarySortTreeDemo.delNode(10);
binarySortTreeDemo.delNode(2);
binarySortTreeDemo.delNode(12);
binarySortTreeDemo.delNode(9);
binarySortTreeDemo.preOrder();
}
}
输出结果:
root未初始化!现选取第一个元素初始化root
value: 7
value: 3
value: 1
value: 2
value: 5
value: 10
value: 9
value: 12
前序遍历:
value: 9
value: 3
value: 2
value: 5
value: 10
value: 12
前序遍历:
value: 5