二叉树的增删改查

首先建立Node

public class Node<T extends Comparable<T>> {
  private T date;
  private int index;
  private Node<T> lchile;
  private Node<T> rchile;
  
  public Node(){
	  
  }
  public Node(T date) {
	  this.date =date;
  }
  public Node(T date,Node<T> lNode,Node<T> rNode) {
    this.date =date;
    this.lchile =lNode;
    this.rchile =rNode;
  }
  
  
public T getDate() {
	return date;
}
public void setDate(T date) {
	this.date = date;
}
public int getIndex() {
	return index;
}
public void setIndex(int index) {
	this.index = index;
}
public Node<T> getLchile() {
	return lchile;
}
public void setLchile(Node<T> lchile) {
	this.lchile = lchile;
}
public Node<T> getrNode() {
	return rchile;
}
public void setrNode(Node<T> rchile) {
	this.rchile = rchile;
}
@Override
public String toString() {
	return "Node [date=" + date + ", index=" + index + ", lchile=" + lchile + ", rchile=" + rchile + "]";
}
 }

增加：

public void add(Node<T> node,T date){
		if (node ==null) {
		System.out.println("头结点为空");
		}else {
			if (node.date.compareTo(date) == -1) {
				if (node.rchile !=null) {
					 add(node.rchile, date);
				}else {
					Node<T> node2 =new Node<>(date);
					node.rchile =node2;
				}
			}else {
				  if (node.lchile !=null) {
						 add(node.lchile, date);
					}else {
						Node<T> node2 =new Node<>(date);
						node.lchile =node2;
					}
			}
			
		}
		 
	}

查找：特定值可以使用递归 如果要查找的值比 头结点的值大 就向右查找，否则向左查找

public Node<T> Search(Node<T> node,T date) {
	
		if (node.date.compareTo(date) == -1 && node.rchile!=null ) {			
			return Search(node.rchile, date);
		}else if (node.date.compareTo(date) == 1 && node.lchile !=null) {
			
			return Search(node.lchile, date);
		}else{				
			return node;
		}
	}

删除：删除分为三种情况：
第一种：如果为叶子结点，则可以直接删除，如图一。

第二种：如果只有左子树或者只有右子树的时候，只要令其左子树或右子树为其父节点的左子树或右子树即可，如图二。

　
第三种：如果节点既有左节点，又有右节点，则我们需要先用中序序列中节点的前驱或后序替换该节点，然后删除其前驱或后序节点。此时该节点的前驱或后序节点必然是没有右孩子或者左孩子的节点，删除方法可以参照第二种，如图三。

public boolean Delete(Node<T> root,T date){
	        //引用当前节点，从根节点开始
	        Node curr = root;
	        //应用当前节点的父节点
	        Node parentNode = root;
	        //是否为左节点
	        boolean isLeftChild = true;
	        //进行比较，查找是否存在要删除的节点
	        while(curr.date.compareTo(date)!=0){
	            parentNode = curr;
	            if(curr.date.compareTo(date)==1){
	                curr = curr.lchile;
	                isLeftChild = true;
	            }else {
	                curr = curr.rchile;
	                isLeftChild = false;
	            }
	            //如果查找不到
	            if(curr == null) {
	                return false;
	            }
	        }
	        //刪除叶子节点
	        if(curr.lchile == null && curr.rchile == null){
	            if(curr == root) {
	                root = null;
	            } else if(isLeftChild) {
	                parentNode.lchile = null;
	            } else {
	                parentNode.rchile = null;
	            }
	        }else if(curr.lchile == null){//删除节点的左节点为空
	            if(curr == root){
	                root = root.rchile;
	            }else if(isLeftChild) {
	                parentNode.lchile = curr.rchile;
	            }else {
	                parentNode.rchile = curr.rchile;
	            }
	        }else if (curr.rchile == null) {//删除节点的右节点为空
	            if(curr == root){
	                root = root.lchile;
	            }else if(isLeftChild) {
	                parentNode.lchile = curr.lchile;
	            }else {
	                parentNode.rchile = curr.lchile;
	            }
	        }else {//如果要删除的节点有左右两个子节点
	            Node successor = getSuccessor(curr);
	            if(curr == root){
	                root = successor;
	            }else if(isLeftChild){
	                parentNode.lchile = successor;
	            }else {
	                parentNode.rchile = successor;
	            }
	            successor.lchile = curr.lchile;
	        }
	        return true;
	    }
	  public Node getSuccessor(Node delNode) {//获取要删除节点的后边的点
	        Node successor = delNode;
	        Node successorParent = delNode;
	        Node curr = delNode.rchile;
	        while(curr != null){
	            successorParent = successor;
	            successor = curr;
	            curr = curr.lchile;
	        }
	        if(successor != delNode.rchile){
	            successorParent.lchile = successor.rchile;
	            successor.rchile = delNode.rchile;
	        }
	        return successor;
	    }

修改 就是先删除之后 在添加。