搜索二叉树和平衡二叉树

搜索二叉树,平衡二叉树,B树，B+树

一.搜索二叉树

//插入某个元素
private boolean insertItem(TreeNode<E> root,E element)//E表示一个类型
{
    TreeNode<E>node=new TreeNode<>();
    node.setElement(element);
    if(root==NULL)
    {
        this.root=node;return true;
    }
    while(root!=NULL)
  {
    int compare_root=element.compareTo(root.element);
    if(compare_root<0)
    {
        if(root.left==NULL)
        {
            root.left=node;return true;
        }
        else
            root=root.left;
    }
    else if(compare_root>0)
    {
        if(root.right==NULL)
        {
            root.right=node;return true;
        }
        else
            root=root.right;
    }
   }
    return false;
}

//查找某个节点的元素值
private TreeNode<E> searchItem(TreeNode<E> root,E contactKey)
{
    while(root!=NULL){
    if(contactKey.compareTo(root.element)>0)
      root=root.right;
    else if(contactKey.compareTo(root.element)<0)
        root=root.left;
    else if(contactKey.compareTo(root.element)==0)
        return root;
    }
    return NULL;
}

//删除某个结点
private boolean removeElement(TreeNode<E> root, E removeElement)//removeElement是要删除的结点
{
    if(root!=NULL){
    TreeNode<E> search_node=searchItem(root,removeElement);
    if(search_node==NULL)return false;
    else
    {
       if(search_node.left==NULL&&search_node.right==NULL)     
       {
           search_node=NULL;return true;
       }
        else if(search_node.left==NULL&&search_node.right!=NULL)
        {
            TreeNode<E> temp=search_node.right;
            if(temp.left!=NULL)
                search_node.left=temp.left;
            if(temp.right!=NULL)
                search_node.right=temp.right;
             search_node=temp;//或者只做值替换，即只把temp的element赋值给search_node
            return true;
        }
        else if(search_node.left!=NULL&&search_node.right==NULL)
        {
            TreeNode<E> Node=search_node.left;
            if(temp.left!=NULL)
                search_node.left=temp.left;
            if(temp.right!=NULL)
                search_node.right=temp.right;
            search_node=temp;
            return true;
        }
        else if(search_node.left!=NULL&&search_node.right!=NULL) 
        //当删除的结点既有左子树又有右子树时，用左子树的最大结点或者右子树的最小结点来代替要删除的结点，这样依然满足搜索二叉树的性质   
        {
               //1.找到继承者父结点  
            TreeNode<E> successorParent =findsuccessorParent(search_node.right)//要从其右子树开始找起 
               //2.替换
            search_node.element=successorParent.left.element;
               //3.删除继承者的结点
            if(successorParent .left.right!=NULL)//如果继承者不是叶子
            {
                successorParent.left=successorParent.left.right;
            }
            else //继承者是叶子
            {
                successorParent.left=NULL; 
            }
            return true;
        }
   }   
 }
    return false;
}

private TreeNode<E> findSuccessorParent(TreeNode<E> currentNode)//类方法,找到继承者的父结点(私有)
{
    TreeNode<E> temp=currentNode;
    TreeNode<E> parent;
    Stack<TreeNode<E>>stack=new Stack<>();
    while(temp!=NULL||!stack.IsEmpty)
    {
        while(temp!=NULL)
        {
            stack.push(temp);
            temp=temp.left;
        }
        if(!stack.IsEmpty)
        {
            stack.pop();
            return stack.pop();//相当于连弹两次，弹出的来是继承者的父结点
        }
    }
    return NULL；//没有找到
}

二.平衡二叉树(AVL)

需要满足两个条件:

1.任意子树都是二叉排序树

2.任意结点的子树都是平衡二叉树(左右结点的高度差不超过1)

public class ALVNode
{
    public int data;
    public int height;
    public ALVNode left;
    public ALVNode right;
    public ALVNode  parent; 
    public ALVNode(int data)
    {
        this.data=data;
        this.height=1;
    }
}

//计算高度
public int GetDepth(ALVNode tree)
{
    if(tree==NULL)return 0;
    int leftdepth=GetDepth(tree.left);
    int rightdepth=GetDepth(tree.right);
    return leftdepth>rightdepth?leftdepth+1:rightdepth+1;
}//递归法求高度




//第二种方法
public int GetDepth(ALVNode root)
{
    if(root.left==NULL&&root.right==NULL)return 1;
    else if(root.left==NULL&&root.right!=NULL)return root.right.height+1;
    else if(root.right==NULL&&root.left!=-NULL)return root.left.height+1;
    else
    {
        return root.left.height>root.right.height?root.left.height+1:root.right.height+1;
    }
}

//计算平衡因子
public int cacBF(ALVNode root)
{
    if(root.right==NULL&&root.left==NULL)return 0;
    else if(root.left==NULL)return 0-root.right.height;
    else if(root.right==NULL)return root.left.height;
    else return root.left.height-root.right.height;
}

//左旋
public ALVNode left_revolve(ALVNode root)
{
    ALVNode oldNode=root;
    ALVNode newNode=root.right;
    ALVNode parent=root.parent;
    if(parent!=NULL)//判断新子树接到根节点父结点的左边还是右边
    {
        if(parent.data>oldNoot.data)//接左边
        {
            parent.left=newNode;
        }
        else
            parent.right=newNode;
    }
    
    newNode.parent=parent;
   //然后把新结点的左结点赋给老结点的右结点
    oldNode.right=newNode.left;
    if(newNode.left!=NULL)
    {
        newNode.left.parent=oldNode;
    }
    //然后把newNode.left更新一下
    newNode.left=oldNode;
    oldNode.parent=newNode;
    //最后更新一下新旧结点的高度
    oldNode.height=GetDepth(oldNode);
    newNode.height=GetDepth(newNode);
    return newNode;
}



//右旋
public ALVNode right_revolve(ALVNode root)
{
      ALVNode oldNode=root;
    ALVNode newNode=root.right;
    ALVNode parent=root.parent;
    if(parent!=NULL)//判断新子树接到根节点父结点的左边还是右边
    {
        if(parent.data>oldNoot.data)//接左边
        {
            parent.left=newNode;
        }
        else
            parent.right=newNode;
    }
     newNode.parent=parent;
   //然后把新结点的左结点赋给老结点的右结点
    oldNode.left=newNode.right;
    if(newNode.right!=NULL)
    {
        newNode.right.parent=oldNode;
    }
    //然后把newNode.right更新一下
    newNode.right=oldNode;
    oldNode.parent=newNode;
    //最后更新一下新旧结点的高度
    oldNode.height=GetDepth(oldNode);
    newNode.height=GetDepth(newNode);
    return newNode;
}

public ALVNode Insert(ALVNode root,int data)
{
    if(root.data>data)
    {
        ALVNode newNode=new ALVNode(data); 
        if(root.left==NULL)
        {
            root.left=newNode;
            newNode.parent=root;
        }
        else 
            Insert(root.left,data);
    }
    else if(root.data<data)
    {
        ALVNode newNode=new ALVNode(data); 
        if(root.right==NULL)
        {
            root.right=newNode;
            newNode.parent=root;
        }
        else 
            Insert(root.right,data);
    }
    GetDepth(root);
    //更新一下root的高度
    if(cacBF(root)==2)LL型
    {
        if(cacBF(root.left)==-1)//LR型
        root.left=left_rovolve(root.left); 
        
        root=right_revolve(root);
    }
    
    else if(cacBF(root)==-2)RR型
    {
        if(cacBF(root.left)==1)RL型
         right.left= right_revolve(root.left);
        
        root=left_revolve(root);
    }
return root;
}

三.B树

B树和AVL树(平衡二叉树) 的差别就是 B树 属于多叉树，又名平衡多路查找树，即一个结点的查找路径不止左、右两个，而是有多个。数据库索引技术里大量使用者B树和B+树的数据结构。一个结点存储多个值(索引)。