二叉查找树,删除，节点开始查找数字

TirNode<Integer> root;

/**
* @param args
*/
public static void main(String[] args) {
int[] arrays={54,18,66,87,36,12,54,81,15,76,57,6,40,99,85,99};
SearchBinaryTree searchBinaryTree=new SearchBinaryTree();
searchBinaryTree.createSearchBinaryTree(arrays);
searchBinaryTree.preOrderTraverse(searchBinaryTree.root);
System.out.println("");
searchBinaryTree.inOrderTraverse(searchBinaryTree.root);
System.out.println("");
searchBinaryTree.deleteNode(66);
System.out.println("删除后的中根：");
searchBinaryTree.inOrderTraverse(searchBinaryTree.root);
}

//创建一个二叉查找树

public void createSearchBinaryTree(int[] list){

TirNode<Integer> node;
for(int i:list){
node = new TirNode<Integer>(i);
insterNode(root, node);
}
}

/**
* 插入一个数
* @param p  插入的根节点
* @param node  需要插入的节点
*/
public void insterNode(TirNode<Integer> p,TirNode<Integer> node){
if (root==null) {
root=node;
return;
}
if(node.data==p.data){
return;
}
if(node.data<p.data){   //小于节点
if(p.leftChild!=null){
insterNode(p.leftChild, node);
}else{
p.leftChild=node;
node.parent=p;
}
}else{
if(p.rightChild!=null){
insterNode(p.rightChild, node);
}else{
p.rightChild=node;
node.parent=p;
}
}
}

/**
* 删除某个数
* @param p
* @param node
* @return
*/
public void deleteNode(int i){

TirNode<Integer> node=searchNode(root,i);
if(node==null){
System.out.println("没有这个数据");
}else{
System.out.println("删除数据："+node.data);
deleteNode(node);
}
}

/**
* 删除结点
* @param node
*/
private void deleteNode(TirNode<Integer> node) {
if(node==null){
return;
}
if(node.leftChild==null&&node.rightChild==null){   //无左右孩子
if(node.parent.leftChild==node){
node.parent.leftChild=null;
}else if(node.parent.rightChild==node){
node.parent.rightChild=null;
}
node=null;
}
else if(node.leftChild==null){      //无左孩子
if(node.parent.leftChild==node){
node.parent.leftChild=node.rightChild;
}else if(node.parent.rightChild==node){
node.parent.rightChild=node.rightChild;
}
node=null;
}else if(node.rightChild==null){   //无右孩子
if(node.parent.leftChild==node){
node.parent.leftChild=node.leftChild;
}else if(node.parent.rightChild==node){
node.parent.rightChild=node.leftChild;
}
node=null;
}else{    //有左右孩子
TirNode<Integer> next=getNextNode(node.rightChild);
int temp=next.data;
deleteNode(next);
node.data=temp;
System.err.println("后继节点："+temp);
}
}

/**
* 获取后继节点
* @param node
* @return
*/
private TirNode<Integer> getNextNode(TirNode<Integer> node) {
if(node.leftChild==null){
return node;
}
return getNextNode(node.leftChild);
}

/**
* 从某个节点开始查找数字
* @param p
* @param i
* @return
*/
private TirNode<Integer> searchNode(TirNode<Integer> p,int i) {
//System.err.println(p.data);
if(p==null){
return null;
}
if(p.data==i){
return p;
}else if(i<p.data){
return searchNode(p.leftChild, i);
}else{
return searchNode(p.rightChild, i);
}
}

/**
* 先根遍历（迭代的形式）
*
* @param node
*/
public void preOrderTraverse(TirNode<Integer> node) {
if (node == null) {
return;
}
System.out.print(node.data+",");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}

/**
* 中根遍历（迭代的形式）
*
* @param node
*/
public void inOrderTraverse(TirNode<Integer> node) {
if (node == null) {
return;
}
inOrderTraverse(node.leftChild);
System.out.print(node.data+",");
inOrderTraverse(node.rightChild);
}

public class TirNode<T> {
public T data;
public TirNode<T> leftChild;
public TirNode<T> rightChild;
public TirNode<T> parent;
public int level;

public TirNode(T data) {
this.data=data;
}
}