文章标题

package datastructures.binarytree;
/**
* 演示二叉树的操作
*/
public class BinaryTree {
/**
* 根节点
*/
private Node root;
/**
* 查找一个节点
* @param key 要查找的id值
* @return
*/
public Node find(int key){
//当前节点
Node current = root;
while(current.getId()!=key){
if(current.getId() > key){
current = current.getLeftChild();
}else if(current.getId() < key){
current = current.getRightChild();
}
if(current == null){
return null;
}
}
return current;
}
/**
* 插入一个节点
* @param id
* @param data
*/
public void insert(int id,int data){
//1：先创建一个新节点
Node newNode = new Node(id,data);

if(root == null){
root = newNode;
}else{
//2：查找要插入的位置
Node current = root;
Node parent = null;

while(true){
parent = current;
if(id < current.getId()){
current = current.getLeftChild();
//如果没有左子节点
if(current == null){
//3：修改相应的节点的属性
parent.setLeftChild(newNode);
return;
}
}else{
current = current.getRightChild();
if(current==null){
//3：修改相应的节点的属性
parent.setRightChild(newNode);
return;
}
}
}
}
}
/**
* 前序获取节点数据
* @param node
*/
public void preOrder(Node node){
if(node != null){
System.out.println(node.getId()+" - ");
preOrder(node.getLeftChild());
preOrder(node.getRightChild());
}
}
/**
* 中序获取节点数据
* @param node
*/
public void inOrder(Node node){
if(node != null){
inOrder(node.getLeftChild());
System.out.println(node.getId()+" - ");
inOrder(node.getRightChild());
}
}
/**
* 后序获取节点数据
* @param node
*/
public void postOrder(Node node){
if(node != null){
postOrder(node.getLeftChild());
postOrder(node.getRightChild());
System.out.println(node.getId()+" - ");
}
}
/**
* 获取最小节点
* @return
*/
public Node getMinNode(){
Node current = root;
Node lastNode = null;
while(current!=null){
lastNode = current;
current = current.getLeftChild();
}
return lastNode;
}
/**
* 获取最大节点
* @return
*/
public Node getMaxNode(){
Node current = root;
Node lastNode = null;
while(current!=null){
lastNode = current;
current = current.getRightChild();
}
return lastNode;
}
/**
* 删除一个节点
* @param key
* @return
*/
public boolean delete(int key){
//1：找到要删除的节点
Node current = root;
Node parent = root;
boolean isLeftChild = true;

while(current.getId()!=key){
parent = current;
if(current.getId() > key){
isLeftChild = true;
current = current.getLeftChild();
}else if(current.getId() < key){
isLeftChild = false;
current = current.getRightChild();
}
if(current == null){
return false;
}
}

//2：没有子节点
if(current.getLeftChild()==null && current.getRightChild()==null){
this.noChildren(parent, current, isLeftChild);
}
//3：只有一个子节点
//只有左节点
else if(current.getRightChild()== null){
this.oneLeftChild(parent, current, isLeftChild);
}
//只有右节点
else if(current.getLeftChild() == null){
this.oneRightChild(parent, current, isLeftChild);
}
//4：有两个子节点
else{
//4.1：找到中序后继节点
Node successor = this.getSuccessor(current);
if(current == root){
root = successor;
}else{
if(isLeftChild){
parent.setLeftChild(successor);
}else{
parent.setRightChild(successor);
}
}
//重新设置successor的leftChild
successor.setLeftChild(current.getLeftChild());
}
return true;
}
/**
* 找到要删除节点的中序后继节点
* @param delNode
* @return
*/
private Node getSuccessor(Node delNode){
Node successor = delNode;
Node successorParent = delNode;
Node current = delNode.getRightChild();
//查找节点
while(current!=null){
successorParent = successor;
successor = current;
current = current.getLeftChild();
}
//设置相应的值
if(successor!=delNode.getRightChild()){
successorParent.setLeftChild(successor.getRightChild());
successor.setRightChild(delNode.getRightChild());
}
return successor;
}
private void oneRightChild(Node parent,Node current,boolean isLeftChild){
if(current == root){
root = current.getRightChild();
}else{
if(isLeftChild){
parent.setLeftChild(current.getRightChild());
}else{
parent.setRightChild(current.getRightChild());
}
}
}
private void oneLeftChild(Node parent,Node current,boolean isLeftChild){
if(current == root){
root = current.getLeftChild();
}else{
if(isLeftChild){
parent.setLeftChild(current.getLeftChild());
}else{
parent.setRightChild(current.getLeftChild());
}
}
}

private void noChildren(Node parent,Node current,boolean isLeftChild){
if(current == root){
root = null;
}else{
if(isLeftChild){
parent.setLeftChild(null);
}else{
parent.setRightChild(null);
}
}
}

public static void main(String[] args) {
BinaryTree t = new BinaryTree();

t.insert(6,6);
t.insert(5,2);
t.insert(8,2433);
t.insert(3, 5);
t.insert(7,77);
t.insert(9,233);

//      System.out.println(t.root.toString());
//
//      t.inOrder(t.find(6));
//
//      Node min = t.getMinNode();
//      Node max = t.getMaxNode();
//      System.out.println("min=="+min);
//      System.out.println("max=="+max);

t.delete(8);

System.out.println(t.root.toString());
}
}