C Transformar algoritmo de Java para C

[UmPrograma]

Transformar algoritmo de java em c

 

Import  Java . Util . ArrayList ;

 classe  pública T23Map < K  extends  Comparável <?  super  K >, V >  {  // K: tipo de chave, V: tipo de valor 
    //////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////// 
    definição comum 
    ////////////////////////////////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

    private  class  Par  {  // tipo de elemento 
        K  key    =  null ;   // chave 
        V  value  =  null ;   // value

        Par ()  {} 
        par ( K  chave ,  V  x )  {  este . Key  =  tecla ;  este . Valor  =  x ;  } 
    }

    private  class  Node  {  // tipo de nó 
        int  nways ;        // 
                         tipo de nó // 2: nó bidirecional 
                         // 3: 
                         nó tridirecional // -2: nó bidirecional (nó ativo na inserção) 
                         // -1: ramificação sem nós (nó activo quando a exclusão) 
        Par  e1   =  nulo ;  // elemento 1 do nó 
        Par  e2   =  nulo ;  // (nulo se a um elemento) elemento 2 do nó 
        do nó  lst  =  null ;  // subárvore esquerda 
        nó  mst  =  nulo ;  // subárvore intermediária 
        Nó  primeiro  =  nulo ;  // subárvore direita

        Node ()        {  Nways  =  0 ;  }           // fazer provisória nó 
        Node ( Par  e )  {  Nways  =  - 2 ;  e1  =  e ;  }  fazer // nó ativo 2 ramos

        // reutilização de memória nó de idade para criar um novo nó 
        do nó  Reutilização ( Int  N ,  Par  E1 ,  Par  E2 ,  Nó  G ,  Nó  H ,  Nó  R )  { 
            Este . Nways  =  N ; 
            Este . E1     =  E1 ; 
            Este . e2     =  E2 ; 
            este . lst    =  l ; 
            este . mst    =  m ; 
            este .rst    =  r ; 
            devolva  isto ; 
        }

        // reutilizar memória nó inferior velha criação de um novo nó 
        Node  reutilização ( int  n ,  Par  e )  { 
            isso . Nways  =  n ; 
            isso . E1     =  e ; 
            isso . E2     =  nulo ; 
            retornar  este ; 
        }

        // converte o nó ativo para o nó normal de 
        Node  um deactivate ()  {  Nways  =  Math . Abs ( Nways );  retornar  este ;  } 
    } 
    privado  Nó  raiz  =  nulo ;  // 2-3 raízes 
    privada  Par  aux ;          // DeleteMax Variável auxiliar para

    // Se t é um nó ativo verdadeiro 
    privada  boolean  ativa ( Node  t )  {  return  t  =!  Null  &&  t . Nways  <  0 ;  }

    // 
    apara ramos extras estendidos void  trim ()  {  if  ( ativo ( root ))  root  =  root . Mst ;  }

    ////////////////////////////////////////////////// ///////////////////////// 
    // insero (insert) 
    /////////////////// ////////////////////////////////////////////////// ///////

    // insere o valor x na raiz da árvore com a chave 
    pública public  void  insert ( tecla K  , V x ) { root = insert ( raiz , novo par ( chave , x )). Deactivate (); }   
             
    

    // inserir uma entrada e na árvore t 
    private  Node  inserção ( nó  t ,  Par  e )  { 
        um if  ( t  ==  nulo )  retornar  new new  Node ( e );  // inserir um nó ativo 
        int  CMP1  =  e . Key . CompareTo ( t . e1 . key ),  cmp2 ; 
        : interruptor  ( t . Nways )  { 
            caso  2 : 
                uma se ( cmp1  <  0 )  { 
                    t . lst  =  inserir ( t . lst ,  e ); 
                    retornar  equilíbrio2Li ( t ); 
                } 
                else  if  ( cmp1  ==  0 )  { 
                    t . e1  =  e ; 
                    retorno  t ; 
                } 
                else  / * cmp1> 0 * /  { 
                    t . Rst  =  inserir ( t . Rst ,  e); 
                    Retorno  Balance2Ri ( t ); 
                } 
            Caso  3 : 
                cmp2  =  e . Key . CompareTo ( t . E2 . Key ); 
                um caso  ( CMP1  <  0 )  { 
                    t . Lst  =  inserção ( t . Lst ,  e ); 
                    retornar  Balance3Li ( t ); 
                } 
                else  if  ( cmp1  ==  0 ) { 
                    T . E1  =  E ; 
                    retorno  t ; 
                } 
                else  um se  ( cmp2  <  0 )  { 
                    t . Mst  =  inserção ( t . Mst ,  e ); 
                    retornar  Balance3Mi ( t ); 
                } 
                else  um se  ( cmp2  ==  0 )  { 
                    t . e2  =  e ; 
                    return  t ; 
                } 
                else / * Cmp2> 0 * /  { 
                    t . Rst  =  inserção ( t . Rst ,  e ); 
                    retornar  Balance3Ri ( t ); 
                } 
            padrão : 
                Buggy ( "inserir" ); 
        } 
        return  nula ; 
    }

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // de equilíbrio no tempo de padrão de ajuste inserção 
    //////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / //////////

    Privado  Nó  Balance2Li ( Node  T )  { 
        Node  A  =  T . Lst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Retorno  A . Reuse ( 3 ,  A . E1 ,  T . E1 ,  A . Lst ,  A . Rst ,  T . rst ); 
    }

    Privado  Nó  Balance2Ri ( Node  T )  { 
        Node  A  =  T . Rst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Retorno  A . Reuse ( 3 ,  T . E1 ,  A . E1 ,  T . Lst ,  A . Lst ,  A . rst ); 
    }

    Privado  Nó  Balance3Li ( Node  T )  { 
        Node  A  =  T . Lst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  R  =  New  Node (); 
        R . Reutilizar ( 2 ,  T . E2 ,  Null ,  T . Mst ,  Null ,  T . Rst ); 
        Retorno  T . Reuse(- 2 ,  t . E1 ,  nulo ,  um . Um desactivar (),  nulo ,  r ); 
    }

    Privado  Nó  Balance3Mi ( Node  T )  { 
        Node  A  =  T . Mst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  R  =  New  Node (); 
        A . Rst  =  R . Reutilizar ( 2 ,  T . E2 ,  Null ,  Um . Rst ,  nulo ,  T . Rst );
        um . lst  =  t . reutilizar ( 2 ,  t . e1 ,  nulo ,  t . lst ,  nulo ,  uma . lst ); 
        retornar  um ; 
    }

    Privado  Nó  Balance3Ri ( Node  T )  { 
        Node  A  =  T . Rst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  L  =  New  Node (); 
        L . Reutilizar ( 2 ,  T . E1 ,  Null ,  T . Lst ,  Null ,  T . mst ); 
        Retorno  T . Reuse(- 2 ,  t . E2 ,  nulo ,  l ,  nulo ,  um . Um desactivar ()); 
    }

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // delete (excluir) 
    /////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////

    // delete o nó da chave da raiz da árvore 
    public  void  delete ( tecla K  ) { root = delete ( raiz , chave ); trim (); }       

    // excluir a chave chave nó da árvore t 
    privado  Nó  apagar ( Node  t ,  K  key )  { 
        um if  ( t  ==  nulo )  de retorno  nulo ; 
        int  CMP1  =  chave . CompareTo ( t . E1 . Key ),  cmp2 ; 
        : Interruptor  ( t . nways )  { 
            caso  2 : 
                if  ( cmp1  <  0 )  { 
                    t. Lst  =  excluir ( t . Lst ,  chave ); 
                    retornar  Balance2Ld ( t ); 
                } 
                else  um if  ( CMP1  ==  0 )  { 
                    um if  ( t . Lst  ==  nulo )  retorno  t . Reuse (- 1 ,  nulo );  // remoção da camada inferior 
                    t . lst  =  DeleteMax ( t . lst );  // suprimido internamente 
                    t. E1  =  aux ; 
                    retornar  Balance2Ld ( t ); 
                } 
                else  / * CMP1> 0 * /  { 
                    t . Rst  =  excluir ( t . Rst ,  chave ); 
                    retornar  Balance2Rd ( t ); 
                } 
            Caso  3 : 
                cmp2  =  chave . CompareTo ( T . E2 . Key ); 
                Se  ( CMP1  <  0 )  { 
                    T. Lst  =  excluir ( t . Lst ,  chave ); 
                    retornar  Balance3Ld ( t ); 
                } 
                else  um if  ( CMP1  ==  0 )  { 
                    um if  ( t . Lst  ==  nulo )  retorno  t . Reutilizar ( 2 ,  t . E2 );  / / camada inferior de exclusão 
                    t . lst  =  DeleteMax ( t . lst ); // eliminada internamente 
                    t . E1  =  aux ; 
                    retornar  Balance3Ld ( t ); 
                } 
                else  um if  ( cmp2  <  0 )  { 
                    t . Mst  =  excluir ( t . Mst ,  chave ); 
                    retornar  Balance3Md ( t ); 
                } 
                else  um if  ( cmp2  ==  0 )  { 
                    if  ( t . mst  ==  null ) retornar  t . reutilizar ( 2 ,  t . e1 );  // deleção na camada inferior 
                    t . MST  =  DeleteMax ( t . mst );  // suprimido internamente 
                    t . e2  =  AUX ; 
                    retornar  Balance3Md ( t ); 
                } 
                else  / * cmp2> 0 * /  { 
                    t . rst  =  excluir ( t . primeiro ,  chave ); 
                    retornar  Balance3Rd ( t); 
                } 
            Padrão : 
                Buggy ( "excluir" ); 
        } 
        return  nula ; 
    }

    // exclui o nó do máximo valor chave da árvore t 
    // retorna madeira valor modificado, eliminando 
    retorna o valor máximo e o valor da chave // Árvore t do aux 
    privada  Nó  DeleteMax ( Node  t )  { 
        um if  ( T . Rst  =!  Null )  { 
            T . Rst  =  DeleteMax ( T . Rst ); 
            interruptor  ( T . Nways )  { 
                Caso  2 : 
                    Retorno  Balance2Rd ( T ); 
                Caso  3 : 
                    Retorno  Balance3Rd( T ); 
                padrão : 
                    Buggy ( "DeleteMax" ); 
            } 
        } 
        else  { 
            : Interruptor  ( t . Nways )  { 
                Caso  2 : 
                    aux  =  t . E1 ; 
                    retorno  t . Reutilizar (- 1 ,  nulo ); 
                Caso  3 : 
                    aux  =  t . E2 ; 
                    Retorno  T . Reuse ( 2 ,  T .e1 ); 
                padrão : 
                    Buggy ( "DeleteMax" ); 
            } 
        } 
        retorno  nulo ; 
    }

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // de equilíbrio no momento do padrão de ajuste eliminação 
    //////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / //////////

    Privado  Nó  Balance2Ld ( Node  T )  { 
        Node  A  =  T . Lst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  R  =  T . Rst ; 
        interruptor  ( R . Nways )  { 
            Caso  2 :  
                A . Mst  =  T . Reuse ( 3 ,  t . E1 ,  r. E1 ,  uma . Mst ,  r . Lst ,  r . Rst ); 
                retornar  um ; 
            Caso  3 : 
                Par  de e  =  r . E1 ; 
                um . Reutilizar ( 2 ,  t . E1 ,  nulo ,  uma . Mst ,  nulo ,  r . Lst ); 
                R . Reutilização ( 2 ,  R .e2 ,  nula ,  r . mst ,  nula ,  r . primeiro ); 
                retorno  t . reutilizar ( 2 ,  e ,  nula ,  um ,  nulo ,  r ); 
            padrão : 
                Buggy ( "Balance2Ld" ); 
        } 
        return  nula ; 
    }

    Privado  Nó  Balance2Rd ( Node  T )  { 
        Node  A  =  T . Rst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  L  =  T . Lst ; 
        interruptor  ( L . Nways )  { 
            Caso  2 : 
                A . Mst  =  T . Reuse ( 3 ,  l . E1 ,  t. E1 ,  l . Lst ,  l . Rst ,  um . Mst ); 
                retornar  um ; 
            Caso  3 : 
                Par  de e  =  l . E2 ; 
                um . Reutilizar ( 2 ,  t . E1 ,  nulo ,  l . Rst ,  nulo ,  uma . Mst ); 
                l . reutilizar ( 2 ,  l .e1 ,  nula ,  l . lst ,  nula ,  l . mst ); 
                retorno  t . reutilizar ( 2 ,  e ,  nula ,  l ,  nula ,  a ); 
            padrão : 
                Buggy ( "Balance2Rd" ); 
        } 
        return  nula ; 
    }

    private  Node  Balance3Ld ( Node  t )  { 
        Node  a  =  t . lst ; 
        um se  (! ativo ( a ))  retorno  t ; 
        Nó  m  =  t . mst ; 
        : Interruptor  ( m . Nways )  { 
            Caso  2 : 
                a . reutilizar ( 3 ,  t . E1 ,  M . E1 ,  Uma .MST ,  m . lst ,  m . rst ); 
                retorno  T . reutilizar ( 2 ,  t . e2 ,  nulo ,  um ,  nulo ,  t . rst ); 
            Caso  3 : 
                Par  de e  =  m . e1 ; 
                um . reutilizar ( 2 ,  t . E1 ,  Null ,  A . mst ,  Null,  H . Lst ); 
                m . Reutilizar ( 2 ,  m . E2 ,  nulo ,  m . Mst ,  nulo ,  m . Rst ); 
                retorno  T . Reutilizar ( 3 ,  e ,  t . E2 ,  um ,  m ,  t . Rst ) ; 
            padrão : 
                Buggy ( "Balance3Ld" ); 
        } 
        return  nula; 
    }

    Privado  Nó  Balance3Md ( Node  T )  { 
        Node  A  =  T . Mst ; 
        Se  (! Ativo ( A ))  Retorno  T ; 
        Nó  R  =  T . Rst ; 
        interruptor  ( R . Nways )  { 
            Caso  2 : 
                A . Reutilizar ( 3 ,  T . E2 ,  R . E1 ,  A .MST ,  r . lst ,  r . rst ); 
                retorno  T . reutilizar ( 2 ,  t . e1 ,  nulo ,  t . lst ,  nulo ,  um ); 
            Caso  3 : 
                Par  de e  =  r . e1 ; 
                um . reutilizar ( 2 ,  t . E2 ,  Null ,  A . mst ,  Null,  R . Lst ); 
                r . Reutilizar ( 2 ,  r . E2 ,  nulo ,  r . Mst ,  nulo ,  r . Rst ); 
                retorno  T . Reutilizar ( 3 ,  t . E1 ,  e ,  t . Lst ,  um ,  r ) ; 
            padrão : 
                Buggy ( "Balance3Md" ); 
        } 
        return  nula; 
    }

    private  Node  Balance3Rd ( Node  t )  { 
        Node  a  =  t . primeiro ; 
        uma se  (! ativo ( a ))  retorno  t ; 
        Nó  m  =  t . mst ; 
        : Interruptor  ( m . Nways )  { 
            Caso  2 : 
                a . reutilizar ( 3 ,  m . E1 ,  T . E2 ,  M .lst ,  m . primeiro ,  um . mst ); 
                retorno  T . reutilizar ( 2 ,  t . e1 ,  nulo ,  t . lst ,  nulo ,  um ); 
            Caso  3 : 
                Par  de e  =  m . e2 ; 
                um . reutilizar ( 2 ,  t . E2 ,  Null ,  M . Rst ,  Null,  Um . Mst ); 
                m . Reutilizar ( 2 ,  m . E1 ,  nulo ,  m . Lst ,  nulo ,  m . Mst ); 
                retorno  T . Reutilizar ( 3 ,  t . E1 ,  e ,  t . Lst ,  m ,  um ) ; 
            padrão : 
                Buggy ( "Balance3Rd" ); 
        } 
        return  nula; 
    }

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // pesquisa, etc. 
    ///////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////

    // Pesquisa por chave. Se o sucesso verdadeiro, falso necessidade de 
    Public  booleana  Membro ( K  Key )  { 
        Nó  T  =  Raiz ; 
        Enquanto  ( T  =!  Null )  { 
            Int  CMP1  =  Key . CompareTo ( T . E1 . Key ),  Cmp2 ; 
            interruptor  ( T . nways )  { 
                caso  2 : 
                    if       ( cmp1  <   0 )  t  = T . Lst ; 
                    Else  Se  ( CMP1  ==  0 )  Retorno  verdadeira ; 
                    Else  / * CMP1> 0 * /  T  =  T . Rst ; 
                    Quebre ; 
                Caso  3 : 
                    Cmp2  =  Key . CompareTo ( T . E2 . Key ); 
                    Se       ( CMP1  <   0 )  t  =  t . Lst ; 
                    else  if  ( cmp1  == 0 )  Retorno  verdadeira ; 
                    Else  Se  ( Cmp2  <   0 )  T  =  T . Mst ; 
                    Else  Se  ( Cmp2  ==  0 )  Retorno  verdadeira ; 
                    Else  / * Cmp2> 0 * /  T  =  T . Rst ; 
                    Pausa ; 
                padrão : 
                    Buggy ( " membro " ); 
            } 
        } 
        Voltar  Falso ; 
    }

    // obtém o valor da chave Se a chave não é para bater retornar um nulo 
    Pública  V  Lookup ( K  Key )  { 
        Nó  T  =  Raiz ; 
        Enquanto  ( T  =!  Null )  { 
            Int  CMP1  =  Key . CompareTo ( T . E1 . Key ),  Cmp2 ; 
            interruptor  ( T . nways )  { 
                caso  2 : 
                    if       ( cmp1  <   0 )  t  = T . Lst ; 
                    Else  Se  ( CMP1  ==  0 )  Retorno  T . E1 . Valor ; 
                    Else  / * CMP1> 0 * /  T  =  T . Rst ; 
                    Quebre ; 
                Caso  3 : 
                    Cmp2  =  Key . CompareTo ( T . E2 . Key ) ; 
                    Se       ( CMP1  <   0 )  T  =  T . Lst ; 
                    Else Se  ( CMP1  ==  0 )  Retorno  T . E1 . Valor ; 
                    Else  Se  ( Cmp2  <   0 )  T  =  T . Mst ; 
                    Else  Se  ( Cmp2  ==  0 )  Retorno  T . E2 . Valor ; 
                    Else  / * Cmp2> 0 * /  T  =  T . Rst ; 
                    Pausa ; 
                padrão : 
                    Buggy ( "Lookup"); 
            } 
        } 
        Retorno  nulo ; 
    }

    // Se o mapa está vazio verdade, se não está vazio falso 
    pública  boolean  isEmpty ()  {  return  raiz  ==  nulo ;  }

    // Esvazie o mapa 
    public  void  clear ()  {  root  =  null ;  }

    // lista de chaves 
    públicas  ArrayList < K >  keys ()  { 
        ArrayList < K >  al  =  new new  ArrayList < K > (); 
        chaves ( raiz ,  al ); 
        retornar  al ; 
    }

    // lista de valores 
    pública  ArrayList < V >  valores ()  { 
        ArrayList < V >  al  =  new new  ArrayList < V > (); 
        valores ( raiz ,  al ); 
        retornar  al ; 
    }

    // Tamanho do mapa 
    public  int  size ()  {  return  keys (). Tamanho ();  }

    // valor mínimo da chave 
    pública  K  min ()  { 
        Nó  t  =  raiz ; 
        um caso  ( t  ==  nulo )  de retorno  nulo ; 
        o tempo  ( t . Lst  =!  Null )  t  =  t . Lst ; 
        retorno  t . E1 . Key ; 
    }

    // valor máximo de chave 
    pública  K  Max ()  { 
        Nó  T  =  Raiz ; 
        Se  ( T  ==  nulo )  Retorno  nulo ; 
        Enquanto  ( T . Rst  =!  Null )  T  =  T . Rst ; 
        Retorno  T . Nways  ==  2  ?  T . E1 . Key  :  T . E2 . Key ; 
    }

    Privadas  Vácuo  Chaves ( Node  T ,  ArrayList < K >  Al )  { 
        Se  ( T  =!  Null )  { 
            interruptor  ( T . Nways )  { 
                Caso  2 : 
                    Chaves ( T . Lst ,  Al ); 
                    Al . Adicionar ( T . E1 . Key ); 
                    Chaves ( t . Rst ,  Al );
                    Quebre ; 
                Caso  3 : 
                    Chaves ( T . Lst ,  Al ); 
                    Al . Adicionar ( T . E1 . Key ;) 
                    Chaves ( T . Mst ,  Al ;) 
                    Al . Adicionar ( T . E2 . Key ); 
                    Chaves ( T . Rst ,  al ); 
                    break ; 
                padrão : 
                    buggy ( "chaves" );
            } 
        } 
    }}

    Privadas  Vácuo  Valores ( Node  T ,  ArrayList < V >  Al )  { 
        Se  ( T  =!  Null )  { 
            interruptor  ( T . Nways )  { 
                Caso  2 : 
                    Valores ( T . Lst ,  Al ); 
                    Al . Adicionar ( T . E1 . Valor ); 
                    Valores ( t . Rst ,  Al); 
                    Pausa ; 
                Caso  3 : 
                    Valores ( T . Lst ,  Al ); 
                    Al . Adicionar ( T . E1 . Valor ); 
                    Valores ( T . Mst ,  Al ); 
                    Al . Adicionar ( T . E2 . Valor ); 
                    Valores ( T . Rst ,  Al ); 
                    Pausa ; 
                padrão : 
                    Buggy ("valores" ); 
            } 
        } 
    }

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // Debug para a rotina 
    //////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / //////

    // converte a árvore 2-3 representar graficamente corda 
    pública  de Cordas  toString ()  { 
        retornar  TOGRAFIA ( "" ,  "" ,  raiz ). ReplaceAll ( "\\ s + $" ,  "" ); 
    }

    // Verifique se a árvore 2-3 está equilibrada 
    public  boolean  balanced ()  {  return  balanceado ( root );  }

    // checar se é provavelmente uma árvore de busca 
    booleana pública  mstValid () { return mstValid ( root ); }     

    privada  estática  final de  Cordas  nl  =  Sistema . getProperty ( "line.separator" ); 
    privada  Cordas  TOGRAFIA ( Cordas  cabeça ,  Cordas  bar ,  Nó  t )  { 
        um if  ( t  ==  nulo )  return  "" ; 
        Cordas  gráfico `  =  "" ; 
        : Interruptor  ( t . nways )  { 
            caso  2 : 
                gráfico  + = TOGRAFIA ( Chefe  Tasu  "" ,  "/" ,  T . Rst ); 
                Graph  Tasu =  Chefe  Tasu  Bar  Tasu  T . E1 . Key  Tasu  Nl ; 
                Graph  Tasu =  TOGRAFIA ( Chefe  Tasu  "" ,  "\" ,  T . Lst ); 
                quebre ; 
            Caso  3 : 
                Cordas  Hb  =  Chefe  Tasu  Bar ; 
                Cordas  Hs  = cabeça  +  "" ; 
                Cordas  k1 ,  k2 , 
                um caso  ( bar . equals ( "/" ))  { 
                    k1  =  hb  +  t . e1 . chave ; 
                    K2  =  hs  +  t . e2 . chave ; 
                } 
                else  um if  ( bar . equals ( "over" ))  { 
                    K1  =  Hs  Tasu  T . E1 .chave ; 
                    K2  =  hb  +  t . e2 . chave ; 
                } 
                else  um if  ( bar . equals ( "\" ))  { 
                    k1  =  hs  +  t . e1 . chave ; 
                    K2  =  hb  +  t . e2 . chave ; 
                } 
                else  { 
                    k1  =  ""  +  t . e1 . key ; 
                    k2  = ""  +  T . E2 . Chave ; 
                } 
                `gráfico  + =  TOGRAFIA ( cabeça  +  "" ,  "/" ,  t . Rst ); 
                ` gráfico  + =  K2  +  nl ; 
                `gráfico  + =  TOGRAFIA ( cabeça  +  "" ,  "por cima" ,  T . mst ); 
                Gráfico  Tasu =  K1  Tasu  Nl ; 
                Gráfico  Tasu =  TOGRAFIA ( Cabeça  Tasu "" ,  "\" ,  T . Lst ); 
                Pausa ; 
            padrão : 
                Buggy ( "Print" ); 
        } 
        Retorno  Graph ; 
    }

    private  boolean  equilibrado ( Node  t )  { 
        um if  ( t  ==  nulo )  retornar  verdadeiro ; 
        boolean  flag ; 
        : Interruptor  ( t . Nways )  { 
            Caso  2 : 
                flag  =  altura ( t . lst )  ==  altura ( t . primeiro ); 
                retorno  flag  &&  equilibrado ( t . lst ) &&  equilibrada ( t . Rst ); 
            Caso  3 : 
                int  hl  =  altura ( t . Lst ); 
                int  hm  =  altura ( t . Mst ); 
                int  h  =  altura ( t . Rst ); 
                bandeira  =  hl  ==  hm  &&  hm  = =  Hr ; 
                Bandeira  =  Bandeira  Andoando  equilibrada ( t . Lst); 
                Flag  =  bandeira  &&  equilibrada ( t . Mst ); 
                flag  =  Bandeira  &&  equilibrada ( t . Rst ); 
                retorno  bandeira ; 
            padrão : 
                Buggy ( "equilibrada" ); 
        } 
        retornar  falso ; 
    }

    // Retorna a altura da árvore 
    private  int  altura ( Node  t )  { 
        um if  ( t  ==  nulo )  return  0 ; 
        int  sh  =  Math . Max ( altura ( t . Lst ),  altura ( t . Rst )); 
        um caso  ( T . Nways  ==  2 )  Retorno  1  Tasu  Sh ; 
        Retorno  1  Tasu  Math .max ( sh ,  altura ( t . mst )); 
    }

    private  boolean  MstValid ( Node  t )  { 
        um if  ( t  ==  nulo )  retornar  verdadeiro ; 
        boolean  flag ; 
        : Interruptor  ( t . Nways )  { 
            Caso  2 : 
                flag  =  pequeno ( t . e1 . chave ,  t . lst )  &&  grande ( t . E1 . Key ,  T .rst ); 
                bandeira  =  bandeira  &&  MstValid ( t . lst )  &&  MstValid ( t . rst ); 
                retorno  bandeira ; 
            Caso  3 : 
                bandeira  =  pequeno ( t . e1 . chave ,  t . lst ); 
                bandeira  =  bandeira  &&  Entre ( t . E1 . Key ,  T . E2 . Key,  T . Mst ); 
                bandeira  =  bandeira  &&  grande ( t . E2 . Chave ,  t . Rst ); 
                bandeira  =  bandeira  &&  MstValid ( t . Lst ); 
                bandeira  =  bandeira  &&  MstValid ( t . Mst ); 
                bandeira  =  bandeira  &&  MstValid ( T . Rst ); 
                Retorno  Bandeira ; 
            padrão: 
                Buggy ( "MstValid" ); 
        } 
        Voltar  Falso ; 
    }

    private  boolean  pequeno ( K  -chave ,  Nó  t )  { 
        um if  ( t  ==  nulo )  retornar  verdadeiro ; 
        boolean  flag  =  chave . compareTo ( t . e1 . key )  >  0 ; 
        : Interruptor  ( t . Nways )  { 
            Caso  2 : 
                flag  =  Bandeira  &&  pequeno ( chave ,  t. Lst )  &&  pequena ( de chave ,  t . Rst ); 
                retorno  bandeira ; 
            Caso  3 : 
                flag  =  Bandeira  &&  chave . CompareTo ( t . E2 . Key )  >  0 ; 
                flag  =  Bandeira  &&  pequena ( de chave ,  t . Lst ); 
                flag  =  flag  &&  small ( chave ,  t. Mst ); 
                flag  =  Bandeira  &&  pequena ( de chave ,  t . Rst ); 
                retorno  bandeira ; 
            padrão : 
                Buggy ( "pequeno" ); 
        } 
        retornar  falso ; 
    }

    private  boolean  Entre ( K  key1 ,  K  key2 ,  Nó  t )  { 
        um if  ( t  ==  nulo )  retornar  verdadeiro ; 
        boolean  flag  =  key1 . compareTo ( t . e1 . key )  <  0 ; 
        flag  =  Bandeira  &&  key2 . compareTo ( t . e1 . chave )  >  0; 
        : Interruptor  ( t . Nways )  { 
            Caso  2 : 
                bandeira  =  bandeira  &&  Entre ( Key1 ,  Key2 ,  t . Lst ); 
                bandeira  =  bandeira  &&  Entre ( Key1 ,  Key2 ,  t . Rst ); 
                retorno  bandeira ; 
            Caso  3 : 
                bandeira  =  bandeira  &&  key1 . compareTo ( t .E2 . Key )  <  0 ; 
                bandeira  =  Flag  Andoando  Key2 . CompareTo ( T . E2 . Key )  >  0 ; 
                bandeira  =  Flag  Andoando  Entre ( Key1 ,  Key2 ,  T . Lst ); 
                bandeira  =  Flag  Andoando  Entre ( Key1 ,  Key2 ,  T . mst ); 
                Bandeira  =  Bandeira  Andoando Entre ( key1 ,  key2 ,  t . Primeiro ); 
                retorno  bandeira ; 
            padrão : 
                Buggy ( "entre" ); 
        } 
        retornar  falso ; 
    }

    private  boolean  grande ( K  -chave ,  Nó  t )  { 
        um if  ( t  ==  nulo )  retornar  verdadeiro ; 
        boolean  flag  =  chave . compareTo ( t . e1 . key )  <  0 ; 
        : Interruptor  ( t . Nways )  { 
            Caso  2 : 
                flag  =  Bandeira  &&  grande ( chave ,  t. Lst )  &&  grande ( chave ,  t . Rst ); 
                retorno  bandeira ; 
            Caso  3 : 
                flag  =  Bandeira  &&  chave . CompareTo ( t . E2 . Key )  <  0 ; 
                flag  =  Bandeira  &&  grande ( chave ,  t . Lst ); 
                flag  =  flag  &&  large ( chave ,  t. Mst ); 
                flag  =  Bandeira  &&  grande ( chave ,  t . Rst ); 
                retorno  bandeira ; 
            padrão : 
                Buggy ( "grande" ); 
        } 
        retornar  falso ; 
    }

     buggy void estático  privado ( local String ) { System . err . println ( lugar + ": Este programa é buggy" ); System . exit ( 1 ); }   
          
        
    

    / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// 
    // rotina principal 
    ///////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////

    public  static  void  main ( String []  args )  { 
        final  int  n  =  30 ; 
        T23Mapa < Integer , Integer >  m  =  novo  T23Map <> (); 
        ArrayList < Integer >  keys  =  novo  ArrayList <> (); 
        para  ( int  i  =  0 ;  i  <  n ;  i ++)  chaves . Adicionar ( i); 
        Java . Util . Coleções . Aleatórias ( Chaves ); 
        Para  ( Int  I  =  0 ;  I  <  N ;  I Tasutasu)  M . Inserir ( Chaves . Get ( I ),  I ); 
        Sistema . Fora . Println ( M ) ; 
        Sistema . Fora . println (); 
        Sistema . Fora . println( "Tamanho:"  Tasu  M . Tamanho ()); 
        Sistema . Fora . Println ( "Chaves:"  Tasu  M . Teclas ());

        definitiva  int  N  =  1000000 ; 
        java . util . aleatório  RNG  =  novo novo  java . util . Aleatório (); 
        m . claro (); 
        java . util . TreeMap < Integer , Integer >  resposta  =  novo novo  java . util . TreeMap <> () ; 
        Int  InsertErrors  =  0 ; 
        Int  DeleteErrors  =  0; 
        Para  ( int  i  =  0 ;  i  <  N ;  i ++)  { 
            int  chave  =  rng . NextInt ( N ); 
            m . Inserção ( chave ,  i ); 
            resposta . O posto ( chave ,  i ); 
        } 
        para  ( int  tecla :  resposta . keySet ())  { 
            int  x  =  m . pesquisa( Key ); 
            Int  Y  =  Resposta . Get ( Key ); 
            Se  ( X  =!  Y )  InsertErrors Tasutasu; 
        } 
        Int  Meio  =  Resposta . Tamanho () / 2 ; 
        Para  ( Int  Key :  Resposta . KeySet ())  { 
            Se  ( metade -  ==  0 )  quebrar ; 
            m . excluir ( chave );
        } 
        Metade  =  resposta . Tamanho () / 2 ; 
        para  ( int  chave :  resposta . KeySet ())  { 
            um if  ( meia -  ==  0 )  quebrar ; 
            um caso  ( m . Membro ( chave ))  DeleteErrors ++; 
        } 
        Sistema . out . println (); 
        System . out . println ( "saldo:"  +  (M . Equilibrado ()       ?  "OK"  :  "NG" )); 
        Sistema . Fora . Println ( "Talvez procurar árvore:"  Tasu  ( M . MstValid ()       ?  "OK"  :  "NG" )); 
        Sistema . Fora . println ( "insert:"  +  ( insertErrors  ==  0  ?  "OK"  :  "NG" )); 
        Sistema . out . println ( "delete:" + ( deleteErrors  ==  0  ?  "OK"  :  "NG" )); 
        para  ( tecla int  : m . keys ()) m . delete ( tecla ); System . out . println ( "Apagar tudo:" + ( m . isEmpty () ? "OK" : "NG" )); } }

 

adicionado 15 minutos depois

http://wwwa.pikara.ne.jp/okojisan/t23-java/index.html