删除节点思路如下:
节点删除一般可以分为以下三种情况:
(1)删除叶子节点(4,7,13)
(2)不删除叶子节点,删除带有一个叶子节点的树结点(14)
(3)删除带有两个叶子节点的树节点(8,3,6)
![](https://i-blog.csdnimg.cn/blog_migrate/ae523a393a33d56dfac5b4354a91649e.png)
第一种
删除方法最简单
设立要删除的节点为targetNode;
找到要删除的节点的父节点parent
判断是父节点的左子树还是右子树
根据节点删除方法:parent.left = null;parent.right = null
![](https://i-blog.csdnimg.cn/blog_migrate/246a9de51bc53bdf5bdba4b157cfc885.png)
第二种
删除方法稍微有点复杂
先找到要删除的节点targetNode;
找到要删除的节点的父节点parent;
判断targetNode的子节点是左子树还是右子树;
判断是父节点的左子树还是右子树;
如果
targetNode下面是左子节点,且:
如果targetNode是parent的左子节点-----parent.left = targetNode.left;
如果targetNode是parent的右子节点-----parent.right = targetNode.left;
如果
targetNode下面是右子节点,且:
如果targetNode是parent的左子节点-----parent.left = targetNode.right;
如果targetNode是parent的右子节点-----parent.right = targetNode.right;
![](https://i-blog.csdnimg.cn/blog_migrate/2310e607c79e8e2cc7688fffad2c75b7.png)
将要删除的节点“14”和左孩子“13”替换,替换后“14”被删除。
如果要删除“10” ,将“10”和“14”交换后删除
第三种
最复杂:
需要删除有两个子树的节点
先找到要删除的节点targetNode;
找到要删除的节点的父节点parent;
从targetNode的右子树找到最小节点;
设临时变量temp,将最小节点的值保存
删除最小节点
targetNode.value = temp;
![](https://i-blog.csdnimg.cn/blog_migrate/ae22c94c6d48f69e0679437122e1949d.png)
左右节点都在,根据排序后的数组顺序
为了不影响别的数的顺序,删掉“8”。
可以和“7”或者“10”交换后删除,这样数组的顺序就不会变啦。
附上代码:
/*
二叉树的节点删除
*/
public class BinarySortTreeDemo {
public static void main(String[] args) {
int arr[]={8,3,10,1,6,14,4,7,13};
BinarySortTree binarySortTree = new BinarySortTree();
//循环的添加节点到二叉排序树
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new Node(arr[i]));
}
//中序遍历二叉排序树
System.out.println("中序遍历二叉排序树");
binarySortTree.infixOrder();
// binarySortTree.delNode(13);
// System.out.println("删除节点后");
// binarySortTree.infixOrder();
binarySortTree.delNode(8);
System.out.println("删除节点后");
binarySortTree.infixOrder();
}
}
//创建二叉排序树
class BinarySortTree{
private Node root;
public Node getRoot() {
return root;
}
//查找要 删除的节点
public Node search(int value){
if (root==null){
return null;
}else {
return root.search(value);
}
}
//查找父节点
public Node searchParent(int value){
if (root==null){
return null;
}else {
return root.searchParent(value);
}
}
//编写方法
//1.返回的是以node为根节点的二叉排序树的最小节点的值
//2.删除以node为根节点的二叉排序树的最小节点
/**
*
* @param node 传入的节点(当做一颗二叉排序树的根节点)
* @return 返回的是以node为根节点的二叉排序树的最小节点的值
*/
public int delRightTreeMin(Node node){
Node target=node;
//循环的查找左节点,就会找到最小值
while (target.left!=null){
target=target.left;
}
//这时target就指向了最小节点
//删除最小节点
delNode(target.value);
return target.value;
}
//删除节点
public void delNode(int value){
if(root==null){
return;
}else {
//1.需求先找到要删除节点targetNode
Node targetNode = search(value);
//如果没有找到要删除的节点
if(targetNode==null){
return;
}
//如果我们发现targetNode没有父节点
//如果们发现当前这颗二叉排序树只有一个节点
if (root.left==null&&root.right==null){
root=null;
return;
}
//去找到targetNode的父节点
Node parent = searchParent(value);
//如果要删除的节点是叶子节点
if(targetNode.left==null&&targetNode.right==null){
//判断targetNode是父节点的左子节点,还是右子节点
if (parent.left!=null&&parent.left.value==value){//是左子节点
parent.left=null;
}else if (parent.right!=null&&parent.right.value==value){//是右子节点
parent.right=null;
}
}else if(targetNode.left!=null&&targetNode.right!=null){//删除有两颗子树的节点
int minVal=delRightTreeMin(targetNode.right);
targetNode.value=minVal;
}else {//删除只有一颗子树的节点
//如果要要删除的节点有左子节点
if (targetNode.left!=null){
if(parent!=null){
if (parent.left.value==value){//是左子节点
parent.left=targetNode.left;
}else{//是右子节点
parent.right=targetNode.left;
}
}else {
root=targetNode.left;
}
}else{ //如果要要删除的节点有右子节点
if (parent!=null){
if (parent.left.value==value){//是左子节点
parent.left=targetNode.right;
}else{//是右子节点
parent.right=targetNode.right;
}
}else {
root=targetNode.right;
}
}
}
}
}
//添加节点的方法
public void add(Node node){
if(root==null){
root=node;//如果root为空直接让root指向node
}else {
root.add(node);
}
}
//中序遍历
public void infixOrder(){
if(root!=null){
root.infixOrder();
}else {
System.out.println("二叉排序树为空,不能遍历");
}
}
}
//创建Node节点
class Node{
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
//查找要删除的节点
/**
*
* @param value 希望删除的节点的值
* @return 如果找到返回该节点,否则返回null
*/
public Node search(int value){
if(value==this.value){//找到就是该节点
return this;
}else if (value<this.value){//如果查找的值小于当前节点,向左子树递归查找
//如果左子节点为空
if(this.left==null){
return null;
}
return this.left.search(value);
}else {//如果查找的值不小于当前节点,向右子树递归查找
//如果右子节点为空
if(this.right==null){
return null;
}
return this.right.search(value);
}
}
//查找要删除节点的父节点
/**
*
* @param value 要找到的节点的值
* @return 返回的是要删除节点的父节点,如果没有就返回null
*/
public Node searchParent(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.searchParent(value);//向左子树递归查找
}else if(value>=this.value&&this.right!=null){
return this.right.searchParent(value);//向右子树递归查找
}else {
return null;//没有找到父节点
}
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
//添加节点的方法
//递归的形式添加节点,注意需要二叉排序树的要求
public void add(Node node){
if(node==null){
return;
}
//判断传入节点的值,和当前子树的根节点的值得关系
if(node.value<this.value){
//如果当前节点的左子节点为null
if(this.left==null){
this.left=node;
}else {
//递归的向左子树添加
this.left.add(node);
}
}else {//添加的节点的值大于当前节点的值
//如果当前节点的左子节点为null
if(this.right==null){
this.right=node;
}else {
//递归的向左子树添加
this.right.add(node);
}
}
}
//中序遍历
public void infixOrder(){
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);
if (this.right!=null){
this.right.infixOrder();
}
}
}