java删除一棵二叉树_数据结构学习--Java删除二叉树节点

想了半天，是真的不好想(手动捂脸)

三种情况需要考虑：

1、该节点是叶子节点，没有子节点

要删除叶节点，只需要改变该节点的父节点的引用值，将指向该节点的引用设置为null就可以了。

2、该节点有一个子节点

改变父节点的引用，将其直接指向要删除节点的子节点。

3、该节点有两个子节点

要删除有两个子节点的节点，就需要使用它的中序后继来替代该节点。

代码

package com.example.deer;

public class Tree {

//根节点

public Node root;

/**

* 插入节点

* @param value

*/

public void insert(long value,String sValue){

//封装节点

Node newNode = new Node(value,sValue);

//引用当前节点

Node current = root;

//引用父节点

Node parent;

//如果root为null，也就是第一次插入的时候

if(root == null){

root = newNode;

return;

}else{

while (true){

//父节点指向当前节点

parent = current;

//如果当前指向的节点数据比插入的要大，则向左走

if(current.data > value){

current = current.leftChild;

if(current == null){

parent.leftChild = newNode;

return;

}

}else{

current = current.rightChild;

if(current == null){

parent.rightChild = newNode;

return;

}

}

}

}

}

/**

* 查找节点

*/

public Node find(long value){

//引用当前节点，从根节点开始

Node current = root;

//循环，只要查找值不等于当前节点的数据项

while(current.data != value){

//进行比较，比较查找值和当前节点的大小

if(current.data > value){

current = current.leftChild;

} else {

current = current.rightChild;

}

if(current == null){

return null;

}

}

return current;

}

/**

* 删除节点

*/

public boolean delete(long value){

//引用当前节点，从根节点开始

Node current = root;

//应用当前节点的父节点

Node parent = root;

//是否为左节点

boolean isleftChild = true;

while(current.data != value){

parent = current;

//进行比较，比较查找值和当前节点的大小

if(current.data > value){

current = current.leftChild;

isleftChild = true;

} else {

current = current.rightChild;

isleftChild = false;

}

if(current == null){

return false;

}

}

//删除叶子节点，也就是该节点没有子节点

if(current.leftChild == null && current.rightChild == null){

if(current == root){

root = null;

}else if(isleftChild){//如果它是父节点的左子节点

parent.leftChild = null;

}else{

parent.rightChild = null;

}

}else if (current.rightChild == null){

if(current == root){

root = current.leftChild;

}else if(isleftChild){

parent.leftChild = current.leftChild;

}else{

parent.rightChild = current.leftChild;

}

}else if (current.leftChild == null){

if(current == root){

root = current.rightChild;

}else if(isleftChild){

parent.leftChild = current.rightChild;

}else{

parent.rightChild = current.rightChild;

}

} else {

Node successor = getSuccessor(current);

if(current == root){

root = successor;

} else if(isleftChild) {

parent.leftChild = successor;

}else{

parent.rightChild = successor;

}

successor.leftChild = current.leftChild;

}

return true;

}

/**

* 寻找中继节点

* @param delNode

* @return

*/

public Node getSuccessor(Node delNode){

Node successor = delNode;

Node successorParent = delNode;

Node current = delNode.rightChild;

while(current != null){

successorParent = successor;

successor = current;

current = current.leftChild;

}

if(successor != delNode.rightChild){

//

successorParent.leftChild = successor.rightChild;

//将删除的节点的整个右子树挂载到中继节点的右子树上

successor.rightChild = delNode.rightChild;

}

return successor;

}

/**

* 前序遍历

*/

public void frontOrder(Node localNode){

if(localNode != null){

//访问根节点

System.out.println(localNode.data + "," + localNode.sData);

//前序遍历左子树

frontOrder(localNode.leftChild);

//前序遍历右子树

frontOrder(localNode.rightChild);

}

}

/**

* 中序遍历

*/

public void inOrder(Node localNode){

if(localNode != null){

//中序遍历左子树

inOrder(localNode.leftChild);

//访问根节点

System.out.println(localNode.data + "," + localNode.sData);

//中序遍历右子树

inOrder(localNode.rightChild);

}

}

/**

* 后序遍历

*/

public void afterOrder(Node localNode){

if(localNode != null){

//后序遍历左子树

afterOrder(localNode.leftChild);

//后序遍历右子树

afterOrder(localNode.rightChild);

//访问根节点

System.out.println(localNode.data + "," + localNode.sData);

}

}

}