数据结构与算法分析java——树2（二叉树类型）

1. 二叉查找树

　　二叉查找树（Binary Search Tree）/  有序二叉树（ordered binary tree）/ 排序二叉树（sorted binary tree）

　　　　1). 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

　　　　2). 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

　　　　3). 任意节点的左、右子树也分别为二叉查找树。

　　　　4). 没有键值相等的节点（no duplicate nodes）。

public class BinarySearchTree<AnyType extends Comparable<? super AnyType>>{
    private static class BinaryNode<AnyType>{
        BinaryNode(AnyType theElement){
        this(theElement,null,null);
        }

        BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType>){
            element=theElement; left=lt; right= rt;
        }

        AnyType element;
        BinaryNode<AnyType> left;
        BinaryNode<AnyType> right;
    }

    private BinaryNode<AnyType> root;

    //构造函数
    public BinarySearchTree(){
        root=null;
    }

    public void makeEmpty(){
        root=null;
    }

    public booolean isEmpty(){
        return root==null;
    }

    public boolean contains(AnyType x){
        return contains(x,root);
    }

    public AnyType findMin()
    {
        if(isEmpty()) throw new UnderflowException();
        return findMin(root).element;
    }

    public AnyType findMax()
    {
        if(isEmpty()) throw new UnderflowException();
        return findMax(root).element;
    }

    public void insert(AnyType x){
        root=insert(x,root);
    }

    public void remove(AnyType x){
        root=remove(x,root);
    }

    public void printTree(){
        if(isEmpty())
            System.out.println("Empty tree");
        else
            printTree(root);
    }

    //二叉树的contains操作
    private boolean contains(AnyType x, BinaryNode<AnyType> t){

        if(t==null)
            return false;

        //Comparable接口的compareTo方法比较两个值
        int compareResult=x.compareTo(t.element);
        if(compareResult<0)
            return contains(x,t.left);
        else if (compareResult>0)
            return contains(x,t.right);
        else
            return true;
    }

    //查找最小值节点
    private BinaryNode<AnyType> findMin(BinaryNode<AnyType> t){
        if(t==null)
            return null;
        else if(t.left==null)
            return t;
        return findMin(t.left);
    }

    //查找最大值节点
    private BinaryNode<AnyType> findMax(BinaryNode<AnyType> t){
        if(t !=null)
            while(t.right!=null)
                t=t.right;
        return t;
    }

    //insert插入，返回对 新树根的引用
    private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t){
        if(t==null)
            return new BinaryNode<AnyType>(x,null,null);

        int compareResult=x.compareTo(t.element);
        if(compareResult<0)
            t.left=insert(x,t.left);
        else if(compareResult >0)
            t.right=insert(x,t.right);
        else
            ;
        return t;
    }

    //删除节点
    private BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t){
        if(t==null)
            return t;
        int compareResult=x.compareTo(t.element);

        if(compareResult<0)
            t.left=remove(x,t.left);
        else if(compareResult>0)
            t.right=remove(x,t.right);
        else if(t.left != null && t.right!=null){
            //两个孩子的情况，将右子树的最小值填充到该节点；
            //在右子树删除最小值节点
            t.element=findMin(t.right).element;
            t.right=remove(t.element.t.right);
        }
        else
            //只有一个孩子
            t=(t.left != null) ? t.left: t.right;
        return t;
    }

    private void printTree(BinaryNode<AnyType> t){
        if(t!=null)
        {
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }

}

2. AVL树

　　平衡二叉树定义（AVL） /  Balanced Binary Tree 或 Height-Balanced Tree：它或者是一棵空树，或者是具有一下性质的二叉查找树-- 它的结点左子树和右子树的深度之差不超过1,而且该结点的左子树和右子树都是一棵平衡二叉树。      平衡因子：结点左子树的深度-结点右子树的深度。（0、1、-1）。

　　四种情况导致二叉树不平衡：

　　针对四种种情况可能导致的不平衡，可以通过旋转使之变平衡。有两种基本的旋转：

　　　　　　1）左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置

　　　　　　2）右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置

（1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2

　　第一列中，在2节点左子树插入D，为了平衡，应该将{2，D}上移一层，A下移一层，以3为根即可，而原来树中B介于3和5之间，因此将B作为5的左子树；

　　第二列中，在2节点的右子树插入D，同理

         

（2）RR：插入一个新节点到根节点的右子树（Right）的右子树（Right），导致根节点的平衡因子由-1变为-2

（3）LR：插入一个新节点到根节点的左子树（Left）的右子树（Right），导致根节点的平衡因子由1变为2

　

（4）RL：插入一个新节点到根节点的右子树（Right）的左子树（Left），导致根节点的平衡因子由-1变为-2

package com.kiritor;
/**
 *二叉平衡树简单实现
 */
public class AvlTree< T extends Comparable< ? super T>>
{
     private static class AvlNode< T>{//avl树节点  

        AvlNode( T theElement )
        {
            this( theElement, null, null );
        }
        AvlNode( T theElement, AvlNode< T> lt, AvlNode< T> rt )
        {
            element  = theElement;
            left     = lt;
            right    = rt;
            height   = 0;
        }
        T           element;      // 节点中的数据
        AvlNode< T>  left;         // 左儿子
        AvlNode< T>  right;        // 右儿子
        int         height;       // 节点的高度
    }  

    private AvlNode< T> root;//avl树根  

    public AvlTree( )
    {
        root = null;
    }
   //在avl树中插入数据，重复数据复略
    public void insert( T x )
    {
        root = insert( x, root );
    }  

    //在avl中删除数据,这里并未实现
    public void remove( T x )
    {
        System.out.println( "Sorry, remove unimplemented" );
    }  

     //在avl树中找最小的数据
    public T findMin( )
    {
        if( isEmpty( ) )
            System.out.println("树空");;
        return findMin( root ).element;
    }
    //在avl树中找最大的数据
    public T findMax( )
    {
        if( isEmpty( ) )
            System.out.println("树空");
        return findMax( root ).element;
    }
   //搜索
    public boolean contains( T x )
    {
        return contains( x, root );
    }  

    public void makeEmpty( )
    {
        root = null;
    }  

    public boolean isEmpty( )
    {
        return root == null;
    }
    //排序输出avl树
    public void printTree( )
    {
        if( isEmpty( ) )
            System.out.println( "Empty tree" );
        else
            printTree( root );
    }  

    private AvlNode< T> insert( T x, AvlNode< T> t )
    {
        if( t == null )
            return new AvlNode< T>( x, null, null );  

        int compareResult = x.compareTo( t.element );  

        if( compareResult < 0 )
        {
            t.left = insert( x, t.left );//将x插入左子树中
            if( height( t.left ) - height( t.right ) == 2 )//打破平衡
                if( x.compareTo( t.left.element ) < 0 )//LL型（左左型）
                    t = rotateWithLeftChild( t );
                else   //LR型（左右型）
                    t = doubleWithLeftChild( t );
        }
        else if( compareResult > 0 )
        {
            t.right = insert( x, t.right );//将x插入右子树中
            if( height( t.right ) - height( t.left ) == 2 )//打破平衡
                if( x.compareTo( t.right.element ) > 0 )//RR型（右右型）
                    t = rotateWithRightChild( t );
                else                           //RL型
                    t = doubleWithRightChild( t );
        }
        else
            ;  // 重复数据，什么也不做
        t.height = Math.max( height( t.left ), height( t.right ) ) + 1;//更新高度
        return t;
    }  

     //找最小
    private AvlNode< T> findMin( AvlNode< T> t )
    {
        if( t == null )
            return t;
        while( t.left != null )
            t = t.left;
        return t;
    }
    //找最大
    private AvlNode< T> findMax( AvlNode< T> t )
    {
        if( t == null )
            return t;
        while( t.right != null )
            t = t.right;
        return t;
    }
    //搜索（查找）
    private boolean contains( T x, AvlNode t )
    {
        while( t != null )
        {
            int compareResult = x.compareTo( (T) t.element );  

            if( compareResult < 0 )
                t = t.left;
            else if( compareResult > 0 )
                t = t.right;
            else
                return true;    // Match
        }
        return false;   // No match
    }
   //中序遍历avl树
    private void printTree( AvlNode< T> t )
    {
        if( t != null )
        {
            printTree( t.left );
            System.out.println( t.element );
            printTree( t.right );
        }
    }
  //求高度
    private int height( AvlNode< T> t )
    {
        return t == null ? -1 : t.height;
    }
    //带左子树旋转,适用于LL型
    private AvlNode< T> rotateWithLeftChild( AvlNode< T> k2 )
    {
        AvlNode< T> k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.height = Math.max( height( k2.left ), height( k2.right ) ) + 1;
        k1.height = Math.max( height( k1.left ), k2.height ) + 1;
        return k1;
    }
    //带右子树旋转，适用于RR型
    private AvlNode< T> rotateWithRightChild( AvlNode< T> k1 )
    {
        AvlNode< T> k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;
        k1.height = Math.max( height( k1.left ), height( k1.right ) ) + 1;
        k2.height = Math.max( height( k2.right ), k1.height ) + 1;
        return k2;
    }
    //双旋转，适用于LR型
    private AvlNode< T> doubleWithLeftChild( AvlNode< T> k3 )
    {
        k3.left = rotateWithRightChild( k3.left );
        return rotateWithLeftChild( k3 );
    }
    //双旋转,适用于RL型
    private AvlNode< T> doubleWithRightChild( AvlNode< T> k1 )
    {
        k1.right = rotateWithLeftChild( k1.right );
        return rotateWithRightChild( k1 );
    }
       // Test program
    public static void main( String [ ] args )
    {
        AvlTree< Integer> t = new AvlTree< Integer>( );
        final int NUMS = 200;
        final int GAP  =   17;
        System.out.println( "Checking... (no more output means success)" );
        for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS )
            t.insert( i );
           t.printTree( );
            System.out.println(t.height(t.root));  

    }
}  

3. 伸展树

伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。

假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法，在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splaytree应运而生。splaytree是一种自调整形式的二叉查找树，它会沿着从某个节点到树根之间的路径，通过一系列的旋转把这个节点搬移到树根去。

伸展树能在O(logn)内完成插入、查找和删除作。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于“伸展”操作。当查找到一个结点后，需要进行“伸展”操作，把这个结点移动到树根。至于伸展操作有两种方式：自底向上和自顶向下。

1）自底向上 

　　所谓的自底向上就是像AVL树那样的“左旋”、“右旋”，多次操作之后把此结点旋转到树根，但这种方式，需要保存查找路径上的各个结点的指针以供旋转之用。

2）自顶向下

　　当我们沿着树向下搜索某个节点X的时候，我们将搜索路径上的节点及其子树移走。我们构建两棵临时的树──左树和右树。

　　没有被移走的节点构成的树称作中树。在伸展操作的过程中：

　　　　1、当前节点X是中树的根。

　　　　2、左树L保存小于X的节点。

　　　　3、右树R保存大于X的节点。

　　开始时候，X是树T的根，左右树L和R都是空的。我们以一个查找2结点的实例，来图解SplayTree的伸展过程。

4.