public void splay( No filho ) {

        while ( !filho.equals( raiz ) ) {

            No pai = filho.getPai();
            No avo = pai.getPai();

            // Se o avo for null, então o pai é a raiz. zig simples.
            if ( avo == null ) {
                // Se for o filho da esquerda é zig_Right
                if ( filho.equals( pai.getEsquerda() ) ) {
                    zig_Right( filho );
                // Se não, é zig_Left
                } else {
                    zig_Left( filho );
                }
            // Se o avo não for null, entao é zig duplo.
                // Se for filho da esquerda:
            } else if ( filho.equals( pai.getEsquerda() ) ) {
                // Se for neto da esquerda, entao é zig_Zig_Right
                if ( pai.equals( avo.getEsquerda() ) ) {
                    zig_Zig_Right( filho );
                // Se não é zig_Zag_Left
                } else {
                    zig_Zag_Left( filho );
                }
                // Se nao for filho da esquerda, é filho da direita:
            } else {
                // Se for neto da direita, entao é zig_Zig_Left
                if ( pai.equals( avo.getDireita() ) ) {
                    zig_Zig_Left( filho );
                // Se não é zig_Zag_Right
                } else {
                    zig_Zag_Right( filho );
                }
            }
        }
    }

    public void zig_Right( No filho ) {
        No pai = filho.getPai();
        No B = filho.getDireita();

        // Muda o pai de filho
        filho.setPai( null );
        // Muda o filho Direito de filho
        filho.setDireita( pai );
        // Muda o pai de pai
        pai.setPai( filho );

        // Muda o filho Esquerdo de pai
        pai.setEsquerda( B );
        // Muda o pai de B
        if ( B != null )
            B.setPai( pai );

        // atualiza a raiz;
        raiz = filho;

    }

    public void zig_Left( No filho ) {
        No pai = filho.getPai();
        No B = filho.getEsquerda();

        // Muda o pai de filho
        filho.setPai( null );
        // Muda o filho Esquerdo de filho
        filho.setEsquerda( pai );
        // Muda o pai de pai
        pai.setPai( filho );

        // Muda o filho Direito de pai
        pai.setDireita( B );
        // Muda o pai de B
        if ( B != null )
            B.setPai( pai );

        // atualiza a raiz;
        raiz = filho;
    }

    public void zig_Zig_Right( No filho ) {
        // Guardo o Pai, Avo e os Filhos da direita de filho e de pai
        No pai = filho.getPai();
        No avo = pai.getPai();
        No B = filho.getDireita();
        No C = pai.getDireita();
        No bisavo = avo.getPai();

        // Mudo o pai e o filho direito de filho
        filho.setPai( bisavo );
        filho.setDireita( pai );

        // Mudo o pai e os filhos de pai
        pai.setPai( filho );
        pai.setEsquerda( B );
        pai.setDireita( avo );

        // Mudo o pai e o filho esquerda de avo
        avo.setPai( pai );
        avo.setEsquerda( C );

        // Atualizo os pais de B e C
        if ( B != null )
            B.setPai( pai );
        if ( C != null )
            C.setPai( avo );

        // Se tiver bisavo:
        if ( bisavo != null ) {
            // Se o avo for o filho Esquerdo de Bisavo:
            if ( bisavo.getEsquerda().equals( avo ) ) {
                bisavo.setEsquerda( filho );
            // Se nao, o avo é filho Direito do Bisavo:
            } else {
                bisavo.setDireita( filho );
            }
        // Se não tiver bisavo, é porque o avo era a raiz. Atualiz a raiz:
        } else {
            raiz = filho;
        }
    }

    public void zig_Zig_Left( No filho ) {
        // Guardo o Pai, Avo e os Filhos da direita de filho e de pai
        No pai = filho.getPai();
        No avo = pai.getPai();
        No bisavo = avo.getPai();
        No B = pai.getEsquerda();
        No C = filho.getEsquerda();

        // Mudo o pai e o filho esquerda de filho
        filho.setPai( bisavo );
        filho.setEsquerda( pai );

        // Mudo o pai e os filhos de pai
        pai.setPai( filho );
        pai.setEsquerda( avo );
        pai.setDireita( C );

        // Mudo o pai e o filho direita de avo
        avo.setPai( pai );
        avo.setDireita( B );

        // Atualizo os pais de B e C
        if ( C != null )
            C.setPai( pai );
        if ( B != null )
            B.setPai( avo );

        // Se tiver bisavo:
        if ( bisavo != null ) {
            // Se o avo for o filho Esquerdo de Bisavo:
            if ( bisavo.getEsquerda().equals( avo ) ) {
                bisavo.setEsquerda( filho );
            // Se nao, o avo é filho Direito do Bisavo:
            } else {
                bisavo.setDireita( filho );
            }
        // Se não tiver bisavo, é porque o avo era a raiz. Atualiz a raiz:
        } else {
            raiz = filho;
        }
    }

    public void zig_Zag_Right( No filho ) {
        // Guardo o Pai, Avo e os Filhos da direita de filho e de pai
        No pai = filho.getPai();
        No avo = pai.getPai();
        No bisavo = avo.getPai();
        No B = filho.getEsquerda();
        No C = filho.getDireita();

        // Muda o pai e os filhos de filho
        filho.setPai( avo.getPai() );
        filho.setEsquerda( pai );
        filho.setDireita( avo );

        //  Muda o pai e o filho direita de pai
        pai.setPai( filho );
        pai.setDireita( B );

        // Mudo o pai e o filho esquerda de avo
        avo.setPai( filho );
        avo.setEsquerda( C );

        // Atualizo os pais de B e C
        if ( B != null )
            B.setPai( pai );
        if ( C != null )
            C.setPai( avo );

        // Se tiver bisavo:
        if ( bisavo != null ) {
            // Se o avo for o filho Esquerdo de Bisavo:
            if ( avo.equals( bisavo.getEsquerda() ) ) {
                bisavo.setEsquerda( filho );
            // Se nao, o avo é filho Direito do Bisavo:
            } else {
                bisavo.setDireita( filho );
            }
        // Se não tiver bisavo, é porque o avo era a raiz. Atualiz a raiz:
        } else {
            raiz = filho;
        }
    }

    public void zig_Zag_Left( No filho ) {
        // Guardo o Pai, Avo e os Filhos da direita de filho e de pai
        No pai = filho.getPai();
        No avo = pai.getPai();
        No bisavo = avo.getPai();
        No B = filho.getEsquerda();
        No C = filho.getDireita();

        // Muda o pai e os filhos de filho
        filho.setPai( avo.getPai() );
        filho.setEsquerda( avo );
        filho.setDireita( pai );

        // Mudo o pai e o filho esquerda de pai
        pai.setPai( filho );
        pai.setEsquerda( C );

        // Mudo o pai e o filho direita de avo
        avo.setPai( filho );
        avo.setDireita( B );

        // Atualizo os pais de B e C
        if ( C != null )
            C.setPai( pai );
        if ( B != null )
            B.setPai( avo );

        // Se tiver bisavo:
        if ( bisavo != null ) {
            // Se o avo for o filho Esquerdo de Bisavo:
            if ( avo.equals( bisavo.getEsquerda() ) ) {
                bisavo.setEsquerda( filho );
            // Se nao, o avo é filho Direito do Bisavo:
            } else {
                bisavo.setDireita( filho );
            }
        // Se não tiver bisavo, é porque o avo era a raiz. Atualiz a raiz:
        } else {
            raiz = filho;
        }
    }

}