java源码二叉树,JAVA之二叉树源码

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;

}

}

}