brnNodebrnNodebrnNodebrnNodebrnNodebrnNodebrnNodebrnNodebrnNode
class brnNode>{
//定义根结点,初始化为空结点
TNode root;
//定义结点数量,初始化为 0
private int size = 0;
//前序遍历
public void preIterator(TNode node){
if (node != null){
System.out.println("==== node.data ==>> " + node.data);
preIterator(node.left);
preIterator(node.right);
}
}
//中序遍历
public void midIterator(TNode node){
if (node != null){
midIterator(node.left);
System.out.println("==== node.data ==>> " + node.data);
midIterator(node.right);
}
}
//后序遍历
public void latIterator(TNode node){
if (node != null) {
latIterator(node.left);
latIterator(node.right);
System.out.println("==== node.data ==>> " + node.data);
}
}
public TNode getIteratorNode(){
return root;
}
//往二叉树中加入结点
public T putValue(T data){
//定义一个空结点,表示根结点
TNode t;
t = root;
size++;
//如果结点为空,则新生成一个结点为根结点
if (t == null){
root = new TNode<>(data, null);
return root.data;
}
//如果结点不为空,则根据二叉树的性质先判断结点是左结点还是右结点
else{
//保存当前结点
TNode p;
p = t;
int ret = 0;
//若当前结点不为空,则继续查找、直到为空为止
while(t != null){
//保存当前结点,继续循环
p = t;
//比较当前数据与新数据
ret = data.compareTo(t.data);
//若新数据小于当前数据,则为左结点
if (ret < 0){
t = t.left;
}
//若新数据大于当前数据,则为右结点
else if (ret > 0){
t = t.right;
}
//若新数据等于当前数据,则替换当前数据
else{
t.data = data;
return t.data;
}
}
//根据当前数据新建结点,并指定父结点
TNode e = new TNode<>(data, p);
//若新数据小于当前数据,则将结点赋给左结点
if (ret < 0){
p.left = e;
}
//若新数据大于当前数据,则将结点赋给右结点
else if (ret > 0){
p.right = e;
}
//返回新结点的值
return p.data;
}
}
//查询结点是否存在
public boolean getNode(T data){
TNode node = getValue(data);
if (node == null){
return false;
}
else{
return true;
}
}
//查询当前结点
public TNode getValue(T data){
TNode p;
p = root;
if (p != null) {
int ret = 0;
while (p != null) {
ret = data.compareTo(p.data);
if (ret < 0) {
p = p.left;
}
else if (ret > 0) {
p = p.right;
}
else {
return p;
}
}
}
return null;
}
//查询后继结点
public TNode getAfterNode(TNode node){
TNode afterNode = node.right;
while (afterNode.left != null){
afterNode = afterNode.left;
}
return afterNode;
}
//删除结点
public boolean deleteValue(T data){
TNode delNode = getValue(data);
TNode parent = delNode.parent;
if (delNode != null){
size--;
//第一种情况,删除结点没有子结点
if ((delNode.left == null) && (delNode.right == null)){
//删除结点为根结点,根结点置为 null
if (delNode == root){
root = null;
}
//删除结点为叶子结点
else{
//若删除结点为父结点的左子结点,则置父结点的左子结点为 null
if (delNode == parent.left){
parent.left = null;
}
//若删除结点为父结点的右子结点,则置父结点的右子结点为 null
else{
parent.right = null;
}
}
//将删除结点置null, 等GC回收
delNode.parent = null;
delNode.data = null;
return true;
}
//第二种情况,删除结点只有左子结点
else if ((delNode.left != null) && (delNode.right == null)){
//删除结点为根结点
if (parent == null){
delNode.left.parent = null;
root = delNode.left;
}
else{
delNode.left.parent = parent;
if (delNode == parent.left){
parent.left = delNode.left;
}
else{
parent.right = delNode.left;
}
}
delNode.parent = null;
delNode.left = null;
delNode.data = null;
return true;
}
//第三中情况,删除结点只有右子结点
else if ((delNode.left == null) && (delNode.right != null)){
//删除结点为根结点
if (parent == null){
root = delNode.right;
delNode.right.parent = null;
}
else{
delNode.right.parent = parent;
if (delNode == parent.left){
parent.left = delNode.right;
}
else{
parent.right = delNode.right;
}
}
delNode.parent = null;
delNode.right = null;
delNode.data = null;
return true;
}
//第四种情况,删除结点有两个子结点
else {
//先查找删除结点的后继结点
TNode node = getAfterNode(delNode);
delNode.data = node.data;
//若后继结点为右子结点,使用右子结点替换被删除结点
if (node == delNode.right){
//删除结点为根结点
if (parent == null) {
root = node;
node.parent = null;
}
//若后继结点为右子结点且有右子结点时:
// 1、将后继结点的右子结点置为删除结点的右子结点;
// 2、将后继结点的右子结点的父结点置为删除结点;
if (node.right != null){
delNode.right = node.right;
node.right.parent = delNode;
}
//若后继结点为右子结点且没有右子结点时:
//置删除结点的右子结点为空;
else{
delNode.right = null;
}
}
//若后继结点为左子结点时
else{
//判断后继结点是否有右子结点:
// 1、若有右子结点,则将后继结点的右子结点赋值给后继结点的父结点上的左子结点
// 2、若没有右子结点,则将后继结点的父结点上的左子结点置 null
if (node.right != null){
node.parent.left = node.right;
}
else{
node.parent.left = null;
}
}
//将后继结点删除,使用GC回收
node.left = null;
node.right = null;
node.parent = null;
node.data = null;
return true;
}
}
return false;
}
//定义一个嵌套结点类
static final class TNode>{
//定义结点数据
private T data;
//定义结点左指针
private TNode left;
//定义结点右指针
private TNode right;
//定义父结点
private TNode parent;
//定义构造函数,给结点赋值
TNode(T data, TNode parent){
this.data = data;
this.parent = parent;
}
}
}