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

package com.sjh.dongnaowork.tree;

public class SearchBinaryTree {

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;
    }
}

}