类实现：
package 树;
import java.util.LinkedList;
import java.util.Queue;
public class BinaryTree {
public TreeNode root;
//插入
public void insert(int value){
//插入成功之后要return结束方法
TreeNode node = new TreeNode(value);
//如果root为空的话插入
if(root == null){
root = node;
return;
}
//定义游标遍历二叉树
TreeNode index = root;
while (true){
if(index.value<value){
//要插入的节点是大的
if(index.right==null){
//插入
index.right=node;
return;
}
index = index.right;
}else {
//新插入的值小
if(index.left==null){
index.left=node;
return;
}
index = index.left;
}
}
}
//广度优先搜索，借助队列实现,如果队列不为空的话就让队列头出队，将出队的左右孩子依次进队
public void levelOrder(){
Queue<TreeNode> queue = new LinkedList<TreeNode>();
if(root!=null){
queue.add(root);
}else {
System.out.println("树为空，请先插入数据");
}
while ((!queue.isEmpty())){
TreeNode index = queue.poll();
System.out.print(index.value + " ");
if(index.left!=null){
queue.add(index.left);
}
if(index.right!=null){
queue.add(index.right);
}
}
System.out.println();
}
//先序遍历
public void beforeOrder(TreeNode node){
if(node == null){
return;
}
System.out.print(" "+node.value+" ");
beforeOrder(node.left);
beforeOrder(node.right);
}
//中序遍历
public void inOrder(TreeNode node){
if(node == null){
return;
}
inOrder(node.left);
System.out.print(" "+node.value+" ");
inOrder(node.right);
}
//后序遍历
public void adterOrder(TreeNode node){
if(node == null){
return;
}
adterOrder(node.left);
adterOrder(node.right);
System.out.print(" "+node.value+" ");
}
//查找
public TreeNode seach(int value){
if(root==null){
return null;
}
//如果不是空的话，定义一个游标，指向根节点
TreeNode index = root;
while (index.value!=value){
//如果目标值大
if(index.value<value){
index = index.right;
}else {
index = index.left;
}
if (index==null){
return null;
}
}
return index;
}
//查找节点的父节点
public TreeNode searchParent(int value){
if (root==null){
return null;
}
//如果不是空的话，定义一个游标，指向根节点
TreeNode index = root;
//判断treeNode是不是目标节点的父节点
while (true){
if((index.left!=null&&index.left.value==value)||(index.right!=null&&index.right.value==value)){
return index;
}else if (value>index.value&&index.right!=null){
//目标值大，index游标往右走
index = index.right;
}else if (value<index.value&&index.left!=null){
//目标值小，index游标往左走
index = index.left;
}else {
//没有父节点
return null;
}
}
}
//找一棵树中的最小值
public int min(TreeNode node){
TreeNode index = node;
if(index.left!=null){
index = index.left;
}
return index.value;
}
//找一棵树中的最大值
public int max(TreeNode node){
TreeNode index = node;
if(index.right!=null){
index = index.right;
}
return index.value;
}
//删除
public void delete(int value){
if (root==null){
System.out.println("此树为空，无需删除");
return;
}
//找到要删除的目标节点
TreeNode targer = seach(value);
//没有找到目标节点
if (targer==null){
System.out.println("没有此节点");
return;
}
//找目标节点的父节点
TreeNode parent = searchParent(value);
//分为三大类
if (targer.left==null&&targer.right==null){
//删除叶子节点
//如果没有父节点
if (parent==null){
root = null;
return;
}
//如果有父节点
//确定要删除的节点是父节点的左孩子还是右孩子
if (parent.left!=null&&parent.left.value==value){
parent.left = null;
}else {
parent.right = null;
}
}else if (targer.left!=null&&targer.right!=null){
//删除有两棵子树的节点
//找到目标节点右子树的最小值(或者左子树的最大值)
int min = min(targer.right);
//删除最小值的节点
delete(min);
//目标节点的值被最小值覆盖
targer.value = min;
}else {
//删除只有一棵字数的节点
//如果没有父节点
if (parent==null){
//判断目标节点有左子树还是有右子树
if(targer.left!=null){
//有左子树
root = targer.left;
}else {
//有右子树
root = targer.right;
}
return;
}
//有父节点
//确定要删除的节点是父节点的左孩子还是右孩子
if (parent.left!=null&&parent.left.value==value){
//要删除的节点是父节点的左孩子
//判断目标节点有左孩子还是右孩子
if(targer.left!=null){
//有左孩子
parent.left = targer.left;
}else {
//有右孩子
parent.left = targer.right;
}
}else {
//要删除的节点是父节点的右孩子
//判断目标节点有左孩子还是右孩子
if(targer.left!=null){
//有左孩子
parent.right = targer.left;
}else {
//有右孩子
parent.right = targer.right;
}
}
}
}
}
Test测试：
package 测试;
import 树.BinaryTree;
public class TreeTest {
public static void main(String[] args) {
// TreeNode t1 = new TreeNode(6);
// TreeNode t2 = new TreeNode(11);
// TreeNode t3 = new TreeNode(18);
// TreeNode t4 = new TreeNode(3);
// TreeNode t5 = new TreeNode(32);
// TreeNode t6 = new TreeNode(8);
// TreeNode t7 = new TreeNode(16);
//
// t1.left = t4;
// t1.right = t6;
// t2.left = t6;
// t2.right = t7;
// t3.left = t7;
// t3.right = t5;
// System.out.println(t1);
BinaryTree tree = new BinaryTree();
BinaryTree tree1 = new BinaryTree();
tree.insert(10);
tree.insert(15);
tree.insert(21);
tree.insert(8);
tree.insert(9);
tree.insert(1);
tree.insert(12);
tree.insert(19);
System.out.println(tree.root);
tree.levelOrder();
tree1.levelOrder();
System.out.print("先序遍历为：");
tree.beforeOrder(tree.root);
System.out.println();
System.out.print("中序遍历为：");
tree.inOrder(tree.root);
System.out.println();
System.out.print("后序遍历为：");
tree.adterOrder(tree.root);
System.out.println();
System.out.println("==========================");
System.out.println("删除之后:");
tree.delete(15);
System.out.print("先序遍历为：");
tree.beforeOrder(tree.root);
System.out.println();
System.out.print("中序遍历为：");
tree.inOrder(tree.root);
System.out.println();
System.out.print("后序遍历为：");
tree.adterOrder(tree.root);
}
}
运行结果：
