Mensagens enviadas por: jef_fe

Deu certoo

vlwww!!!

Tentei fazer isso
colocar dentro do construtor
display = Display.getDisplay();

mais aparece o seguinte errro

cannot find symbol
symbol: method getDisplay()
location: class com.sun.lwuit.Display
----

Por exemplo tou com essa tela...como faço para chama essa tela
só um exemplo só!!!

package com.sun.lwuit.monografia1;

import com.sun.lwuit.layouts.BoxLayout;
import com.sun.lwuit.Button;
import com.sun.lwuit.ButtonGroup;
import com.sun.lwuit.Command;
import com.sun.lwuit.Component;
import com.sun.lwuit.Container;
import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Label; // declaração das bibliotecas
import com.sun.lwuit.RadioButton; 
import com.sun.lwuit.events.ActionEvent;
import com.sun.lwuit.events.ActionListener;
import com.sun.lwuit.layouts.BoxLayout;
import com.sun.lwuit.layouts.FlowLayout;
import com.sun.lwuit.monografia1.TreeDemo;
import com.sun.lwuit.plaf.UIManager;
import com.sun.lwuit.util.Resources;
import com.sun.midp.lcdui.DisplayManager;
import java.io.IOException;
import java.io.InputStream;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Displayable;

/**
 * @author
 */
public class Temas extends Demo {
    private Display display;
    protected DisplayManager displayMgr;
    
   
    public Temas(){
   
       
     
    }
    
    
     
     
     
    public String getName() {
        return "Temas";
    }

protected  void execute( final Form f) {

f.setLayout(new BoxLayout(BoxLayout.Y_AXIS));
         final ButtonGroup group1 = new ButtonGroup();
          
         Label title = new Label("Por Favor Escolha o Tema:");
         title.getStyle().setMargin(0, 0, 0, 0);
         title.getStyle().setBgTransparency(70);
         f.addComponent(title);
         
          final RadioButton rb1 = new RadioButton("Movimento Uniforme - (MU)");
          final RadioButton rb2 = new RadioButton("Movimento Uniformemente Variado - (MUV)");
          RadioButton rb3 = new RadioButton("Tempo");
          RadioButton rb4 = new RadioButton("Acelaração");
          RadioButton rb5 = new RadioButton("Distância");
          
          group1.add(rb1);
          group1.add(rb2);
          group1.add(rb3);      
          group1.add(rb4);
          group1.add(rb5);
          
          f.addComponent(rb1);
          f.addComponent(rb2);
          f.addComponent(rb3);
          f.addComponent(rb4);
          f.addComponent(rb5);
          
        Button updateButton = new Button("----OK----");
        updateButton.setAlignment(Button.CENTER);
        updateButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
            
                      
                //if( evt.getSource()==rb1){
                   if( rb1.isSelected() == true){
                       System.out.println("deu certo, heheh conseguieeee");
                        FontDemo p =new FontDemo();
                        
                          
                        InputStream is = getClass().getResourceAsStream("help.txt");
                        try
                        {
                            StringBuffer sb = new StringBuffer();
                            int chr,  i= 0;
                            //lê ate o final da cadeia
                            while((chr =  is.read())!=-1)
                                sb.append((char) chr);
                            
                        }
                        catch (Exception e)
                                {
                                System.out.println("não é possilvel abrir");
                                }
                         Display.init(new RenderingDemo());
                    RenderingDemo i = new RenderingDemo();
                    String help = getHelp();
                    
                                }
                           
                }
            }
        );
        Container buttonPanel = new Container(new FlowLayout(Component.CENTER));
        buttonPanel.addComponent(updateButton);
        f.addComponent(buttonPanel);
    }
          
    
    // Quando é solicitado a ajuda
    protected  String getHelp() {
        return "O estudante pode optar por escolher vários temas entre, aceleração MU, MUV, Tempo" +
                " "+
                "";
    }

}

Pessoal tou com uma duvida basica utilizando esse Framework. Tenho uma tela, como faço para chamar essa bendita tela.

Agradeço pra quem me ajudar.

Muito Boum esse tutorial!!!!!!!

valeu deu certo

não deu certo alguem tem uma outra opnião

boum galera tou tendo dificuldade em fazer a rotação de um quadrado, alguem tem uma ideia como faço isso, eu tentei fazer mais ñ tá dando certo

// função quadrado
import java.awt.Graphics;
import javax.swing.JOptionPane;

public class Translação extends javax.swing.JFrame {

int x1, y1, x2, y2;// variaveis das coordenadas
    int t, raio, graus, a, b; //Variaveis de controle
    double sen, cos, rad, z1, w1, z2, w2;
    //private int vx[];

String dados;//variavel responsavel para pegar os dados

public Translação() {
        initComponents();
    }

@SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

Desenhar_Quadrado = new javax.swing.JButton();
        Cima = new javax.swing.JButton();
        Baixo = new javax.swing.JButton();
        Direita = new javax.swing.JButton();
        Esquerdo = new javax.swing.JButton();
        Rotaciona = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

Desenhar_Quadrado.setText("Desenhar");
        Desenhar_Quadrado.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                Desenhar_QuadradoActionPerformed(evt);
            }
        });

Cima.setText("/\\");
            Cima.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    CimaActionPerformed(evt);
                }
            });

Baixo.setText("\\/");
            Baixo.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    BaixoActionPerformed(evt);
                }
            });

Direita.setText(">");
            Direita.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    DireitaActionPerformed(evt);
                }
            });

Esquerdo.setText("<");
            Esquerdo.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    EsquerdoActionPerformed(evt);
                }
            });

Rotaciona.setText("Rotacionar");
            Rotaciona.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    RotacionaActionPerformed(evt);
                }
            });

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
            getContentPane().setLayout(layout);
            layout.setHorizontalGroup(
                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                    .addContainerGap()
                    .addComponent(Desenhar_Quadrado)
                    .addGap(64, 64, 64)
                    .addComponent(Rotaciona)
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 170, Short.MAX_VALUE)
                    .addComponent(Esquerdo)
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                        .addComponent(Cima)
                        .addComponent(Baixo))
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                    .addComponent(Direita)
                    .addContainerGap())
            );
            layout.setVerticalGroup(
                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(layout.createSequentialGroup()
                    .addContainerGap(282, Short.MAX_VALUE)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                            .addComponent(Cima)
                            .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                                .addComponent(Baixo)
                                .addComponent(Desenhar_Quadrado)
                                .addComponent(Rotaciona))
                            .addContainerGap())
                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                            .addComponent(Esquerdo)
                            .addGap(23, 23, 23))
                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                            .addComponent(Direita)
                            .addGap(23, 23, 23))))
            );

pack();
        }// </editor-fold>

private void Desenhar_QuadradoActionPerformed(java.awt.event.ActionEvent evt) {                                                  
     // bloco para pegar os dados que são inserido pelo usuario
        dados = JOptionPane.showInputDialog("Digite do Eixo X1: ");
        x1 = Integer.parseInt(dados);
        //dados="";

dados = JOptionPane.showInputDialog("Digite do Eixo Y1: ");
        y1 = Integer.parseInt(dados);
        //dados="";

//Usuário entra com o tamanho do Quadrado
        dados = JOptionPane.showInputDialog("Digite o Tamanho do Quadrado: ");
        t = Integer.parseInt(dados);
        //dados="";

x2=x1+t;//atribui o valor para x2
        y2=y1+t;//atribui o valor para y2
        Quadrado( x1, y1, x2, y2);
    }

// dados para translação
    private void CimaActionPerformed(java.awt.event.ActionEvent evt) {                                     
        Quadrado( x1, y1=y1-10, x2, y2=y2-10);
        repaint();
    }

private void BaixoActionPerformed(java.awt.event.ActionEvent evt) {                                      
        Quadrado( x1, y1=y1+10, x2, y2=y2+10);
        repaint();
    }

private void DireitaActionPerformed(java.awt.event.ActionEvent evt) {                                        
        Quadrado( x1=x1+10, y1, x2=x2+10, y2);
        repaint();
    }

private void EsquerdoActionPerformed(java.awt.event.ActionEvent evt) {                                         
        Quadrado( x1=x1-10, y1, x2=x2-10, y2);
        repaint();
    }

//função para rotação
        private void RotacionaActionPerformed(java.awt.event.ActionEvent evt) {                                          
        dados = JOptionPane.showInputDialog("Digite o Angulo da Rotação: ");
        graus = Integer.parseInt(dados);

rad = Math.toDegrees(graus);
        sen = Math.sin(rad);
        cos = Math.cos(rad);
        sen = sen*-1;
        cos = cos*-1;

z1 = (x1*cos - y1*sen);
        z2 = (x2*cos - y2*sen);
        w1 = (x1*sen + y1*cos);
        w2 = (x2*sen + y2*cos);

x1 = (int) z1;
        x2 = (int) z2;
        y1 = (int) w1;
        y2 = (int) w2;

JOptionPane.showMessageDialog(null, "z1= "+z1+", z2= "+z2+", w1= "+w1+", w2= "+w2+"\n"+
                                        "x1= "+x1+", x2= "+x2+", y1= "+y1+", y2= "+y2+"\nsen= "+sen+", cos= "+cos);
        Quadrado(x1,y1,x2,y2);
       // repaint();
    }

public void Quadrado(int x1, int y1, int x2, int y2){
	int x, y;//variaveis auxiliares

Graphics graphics = getGraphics();

for (x=x1;x<=x2;x++){//Desenha reta pixel a pixel rastreando por x
                graphics.drawLine(x,y1,x,y1);
                graphics.drawLine(x,y2,x,y2);
        }

for(y=y1;y<=y2;y++){//Desenha reta pixel a pixel rastreando por y
                graphics.drawLine(x1,y,x1,y);
                graphics.drawLine(x2,y,x2,y);
        }
    }
    //método que desenha o objeto
	public void paint(Graphics g){
		super.paint(g);
           Quadrado( x1, y1, x2, y2);
	}

public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new Translação().setVisible(true);
            }
        });
    }

// Variables declaration - do not modify                     
    private javax.swing.JButton Baixo;
    private javax.swing.JButton Cima;
    private javax.swing.JButton Desenhar_Quadrado;
    private javax.swing.JButton Direita;
    private javax.swing.JButton Esquerdo;
    private javax.swing.JButton Rotaciona;
    // End of variables declaration

}

hummmmmm

isso mesmo!!!
vc pode me dar uma ideia como faço isso

boum galera tou com um problema, tou gerando uma figura, mais eu queria mover ela de lugar e não estou conseguindo
alguem tem uma opnião, como fazer isso

import java.awt.*;
import java.awt.event.*;//IMPORTAÇÃO DAS BIBLIOTECAS
import javax.swing.*;

// CRIAÇÃO DO FRAME
public class casa extends JFrame{
int quad;

JLabel botao;
  int x1, y1, x2, y2, t;// variaveis das coordenadas
  String dados;//variavel responsavel para pegar os dados
  JLabel palavra;

public casa() {//classe construtor
    super("Computação Grafica");

// exibição do frame
    Container c = getContentPane();
    c.setLayout(new BorderLayout());

// Cria um JLabel
   botao = new JLabel();
    c.add(botao, BorderLayout.CENTER);
    // Cria um botão

JButton btn = new
      JButton("<<Desenhar Quadrado>>");
    btn.addActionListener(
      new ActionListener(){
        public void actionPerformed(ActionEvent e){
            Graphics graphics = botao.getGraphics();
            
            // bloco para pegar os dados que são inserido pelo usuario
                dados = JOptionPane.showInputDialog("Digite do Eixo X1: ");
                x1 = Integer.parseInt(dados);
                dados="";

dados = JOptionPane.showInputDialog("Digite do Eixo Y1: ");
                y1 = Integer.parseInt(dados);
                dados="";

//Usuário entra com o tamanho do casa
                dados = JOptionPane.showInputDialog("Digite o Tamanho do Quadrado: ");
                t = Integer.parseInt(dados);
                dados="";

x2=x1+t;//atribui o valor para x2
                y2=y1+t;//atribui o valor para y2

Quadrado(x1,y1,x2,y2);

}
      }
    );

// Adiciona o botão à janela
   c.add(btn, BorderLayout.SOUTH);

setSize(300,300);
    setVisible(true);
  }

public void Quadrado(int x1, int y1, int x2, int y2)
{
	int x, y;//variaveis auxiliares

Graphics graphics = getGraphics();//função responsavel para
                                                 //exibir os pixel na tela

for (x=x1;x<=x2;x++){//Desenha reta pixel a pixel rastreando
                        graphics.drawLine(x,y1,x,y1);       //por x
                        graphics.drawLine(x,y2,x,y2);
                }

for(y=y1;y<=y2;y++){//Desenha reta pixel a pixel rastreando
                        graphics.drawLine(x1,y,x1,y);       //por y
                        graphics.drawLine(x2,y,x2,y);
                }

}
public void paint(Graphics g) {
        super.paint(g);
       Quadrado(x1,y1,x2,y2);
     
    }
 public class MouseHandler extends MouseAdapter {
        private boolean mouseDownOnQuad = false;
        @Override
        public void mousePressed(MouseEvent e) {
            mouseDownOnQuad =contains(e.getPoint());
        }

@Override
        public void mouseReleased(MouseEvent e) {
            mouseDownOnQuad = false;
        }

@Override
        public void mouseDragged(MouseEvent e) {
            if (!mouseDownOnQuad)
                return;
            Quadrado(x1,y1,x2,y2);
            repaint();
        }
    }

public static void main(String args[]){
  casa a = new   casa();
    a.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

eu pensei assim

lembrando que os valores tem k ser y1==y2 e x1!=x2

bom pessoal tou querendo adaptar a equação da reta para desenhar um quadrado mais não tou conseguindo
eu keria a opnião de vc's como faço isso

import java.awt.*;
import java.awt.event.*;//IMPORTAÇÃO DAS BIBLIOTECAS
import javax.swing.*;
import java.awt.Graphics;

// CRIAÇÃO DO FRAME
public class Quadrado extends JFrame{
  JLabel botao;
  int x1, y1, x2, y2;// variaveis das coordenadas
  String dados;//variavel responsavel para pegar os dados
  JLabel palavra;

public Quadrado() {//classe construtor
    super("Computação Grafica");

// exibição do frame
    Container c = getContentPane();
    c.setLayout(new BorderLayout());

// Cria um JLabel
   botao = new JLabel();
    c.add(botao, BorderLayout.CENTER);
    // Cria um botão

JButton btn = new
      JButton("<<Desenhar Um Quadrado>>");
    btn.addActionListener(
      new ActionListener(){
        public void actionPerformed(ActionEvent e){
            Graphics graphics = botao.getGraphics();
             Color corAnt = graphics.getColor();
            // função para pegar os dados que são inserido pelo usuario
                        dados = JOptionPane.showInputDialog("Digite do Eixo X1: ");
			x1 = Integer.parseInt(dados);
			dados="";

dados = JOptionPane.showInputDialog("Digite do Eixo Y1: ");
			y1 = Integer.parseInt(dados);
			dados="";
                  
			
                        dados = JOptionPane.showInputDialog("Digite do Eixo X2: ");
			x2 = Integer.parseInt(dados);
			dados="";

dados = JOptionPane.showInputDialog("Digite do Eixo Y2: ");
			y2 = Integer.parseInt(dados);
			dados="";

if(y1==y2){
                           DesenhaQuadrado(x1=x1+60,y1=y1+60,x2=x2+60,y2=y2+60);
                           DesenhaQuadradol(x1=x1-20,y1=y1-20,x2=x2-20,y2=y2-20);
                       }else{
                           if(x1==x2){
                               DesenhaQuadrado(x1,y1,x2,y2);
                               DesenhaQuadrado(x1=x1-20,y1,x2=x2-20,y2);
                           }
                       }
                                 
        }
      }
    );

// Adiciona o botão à janela
   c.add(btn, BorderLayout.SOUTH);
setSize(300,300);
    setVisible(true);
   
  }

public void DesenhaQuadrado(int x1, int y1, int x2, int y2)
{
	//float m, b;// calcular a inclinação da reta
	int x, y;//variaveis auxiliares

Graphics graphics = botao.getGraphics();//função responsavel para
                                                 //exibir os pixel na tela

//se as coordenas y1 e y2 forem iguais
                //desenha uma reta na horizontal
                    if (y1 == y2)
		{
			
                        for (x=x1;x<=x2;x++)
				graphics.drawLine(x,y1,x,y1);
                                
                        }
		else
		{
                //se as coordenas x1 e x2 forem iguais
                //desenha uma reta na horizontal
			if (x1==x2)
			//for(y=y1;y<=y2;y++){
                        {
				for(y=y1;y<=y2;y++)
					graphics.drawLine(x1,y,x1,y);

}
                         
			
}

}

//função principal
  public static void main(String args[]){
    Quadrado a = new Quadrado();
    a.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

void MidPointLine (int x1,int x2, int y1,int y2)
y1;

serve em c

/*************************************************/
#include <stdio.h>
#include <stdlib.h>
/*************************************************/
/* ESTRUTURA DOS NÓS */
typedef struct no_arvore{
    int info,altura;
    struct no_arvore *esq, *dir;
}*no_arv;
/*************************************************/
/* ALOCA MEMÓRIA */
no_arv aloca_no_arv(){
  no_arv aux=(struct no_arvore*)malloc(sizeof(struct no_arvore));
  if (aux==NULL)
     printf("\n\n\t\tNAO FOI POSSIVEL ALOCAR MEMORIA."); 
  return aux;
}
/*************************************************/
/* RETORNA ALTURA */
int altura(no_arv raiz ){
    if( raiz == NULL )
        return 0;
    else
        return raiz->altura;
}
/*************************************************/
/* CALCULAR ALTURA */
int calcular_altura(no_arv esq, no_arv dir ){
    int ae, ad;
    ae=altura(esq);
    ad=altura(dir);
       if(ae>ad)
           return ae+1;
       else
           return ad+1;
}
/****************************************************/
/* ALTURA MAIOR */
int altura_maior(int a, int b){
  if (a>=b)
    return a;
  else return b;
}
/****************************************************/
/* ROTAÇÂO A DIREITA */
no_arv rot_dir(no_arv no){
    no_arv aux;
    aux = no->esq;
    no->esq = aux->dir;
    aux->dir = no;
    no->altura = altura_maior(altura(no->esq),altura(no->dir))+1;
    aux->altura = altura_maior(altura(aux->esq),altura(no))+1;
    return aux; 
}
/****************************************************/
/* ROTAÇÂO A ESQUERDA */
no_arv rot_esq(no_arv no){
    no_arv aux;
    aux = no->dir;
    no->dir = aux->esq;
    aux->esq = no;
    no->altura = altura_maior(altura(no->esq),altura(no->dir))+1;
    aux->altura = altura_maior(altura(aux->dir),altura(no))+1;
    return aux; 
}
/****************************************************/
/* ROTAÇÂO DUPLA ESQUERDA-DIREITA */
no_arv rot_esq_dir(no_arv no){
    no->esq = rot_esq( no->esq );
    return rot_dir(no);
}
/****************************************************/
/* ROTAÇÂO DUPLA DIREITA-ESQUERDA */
no_arv rot_dir_esq(no_arv no){
    no->dir=rot_dir(no->dir);
    return rot_esq(no);
}
/****************************************************/
/* INSERE NO */
void insere(no_arv *no, int x){
	if (*no == NULL){
		*no = aloca_no_arv();
		(*no)->info=x;
		(*no)->esq = NULL;
		(*no)->dir = NULL;
	}else {
		if (x < (*no)->info)
			insere(&((*no)->esq), x);
        else
            insere(&((*no)->dir), x);
	}
	/* atualiza altura dos que estão acima*/
	(*no)->altura=calcular_altura((*no)->esq,(*no)->dir);
	verificaavl(no);
}
/****************************************************/
/* CARREGA ARVORE DO ARQUIVO "arvore.txt" */
void carrega_arvore(no_arv *no){
    FILE *arquivo;	
    char str_no[5],x;
    arquivo=fopen ("arvore.txt","r");  
    if (!arquivo)
       printf("Não foi possivel abrir  o arquivo arvore.txt");
    else
       x=getc(arquivo);       
       fseek(arquivo,-1,SEEK_CUR); 
       while (x!=EOF){  
          fgets(str_no,5,arquivo);
          insere(no,atoi(str_no));                     
          x=getc(arquivo);
          fseek(arquivo,-1,SEEK_CUR); 
       }    
}
/****************************************************/
/* BUSCA ELEMENTO NA ARVORE */
no_arv busca(no_arv no,int x){
     static int cont=0;
     if(no==NULL){
       cont=0;
       return(NULL);
     }
     if(x==no->info){
       printf(" Encontrado no nivel: %d",cont);
       cont=0;
       return(no);
     }
     if(x<no->info){
      cont++;
      return(busca(no->esq,x));
     }
     if(x>no->info){
      cont++;
      return(busca(no->dir,x));
     }
}
/****************************************************/
/* RETORNA MAIOR */
no_arv retorna_maior(no_arv *no){
	no_arv aux;
	aux = *no;
	if (aux->dir==NULL){
		*no=(*no)->esq;
		return (aux);
	}else
		return (retorna_maior(&((*no)->dir)));
}
/****************************************************/
/* VERIFICA AVL */
void verificaavl(no_arv *no){
  if ((*no)!=NULL){
       if ( (altura((*no)->dir) - altura((*no)->esq))==-2){
            if ( (altura((*no)->esq->dir) - altura((*no)->esq->esq) )==-1)
               *no=rot_dir(*no);
            else
               *no=rot_esq_dir(*no);
       }else
           if ( (altura((*no)->dir) - altura((*no)->esq))==2){
                if((altura((*no)->dir->dir)-altura((*no)->dir->esq))==1)
                    *no=rot_esq(*no);
                else
                    *no=rot_dir_esq(*no);
           }    
    (*no)->altura=calcular_altura((*no)->esq,(*no)->dir);         
    if((*no)->esq!=NULL)   
        verifica_avl(&((*no)->esq));
    if((*no)->dir!=NULL)
        verifica_avl(&((*no)->dir));  
  }

}

/****************************************************/
/* EXCLUI NO */
int exclui(no_arv *no, int x){
    static int alt;
	no_arv aux;
	int resultado;
	if (*no == NULL)
		return 0;        		
    if ((*no)->info==x){ //encontrou
		aux=*no;
		/* se não tiver filho na esquerda */
		if ((*no)->esq==NULL)
			*no=(*no)->dir; /*então o filho da direita substitui */ 
		else 
		    /* se não tem filho a direita */
			if ((*no)->dir==NULL) 
			   *no=(*no)->esq; /* então o filho da esquerda substitui */
   			else{ /* senão possui dois filhos */
			   aux=retorna_maior(&((*no)->esq)); /* busca o substituto */
			   (*no)->info=aux->info; 
		    }
		free (aux); /* ou é folha */
		return 1;
	}else{
		if (x<(*no)->info)
		    return (exclui(&((*no)->esq),x)); 
		else
			return (exclui(&((*no)->dir),x));
	}
}
/****************************************************/
/* DESTRUIR ARVORE */
no_arv destruir_arvore(no_arv *no){
     if(*no==NULL)
       printf("\n\tEsta vazia\n");
       return NULL; /* para garantir o retorno NULL mesmo que a raiz já seja NULL */
     if((*no)->esq!=NULL)
        (*no)->esq=destruir_arvore(&((*no)->esq));
     if((*no)->dir!=NULL)
        (*no)->dir=destruir_arvore(&((*no)->dir));
     free(no);
     return NULL;
     printf("\nVoltando um nivel...");     
}
/*************************************************/
/* IN_ORDEM */
void in_ordem(no_arv no){
  if (no!=NULL){
     if(no->esq!=NULL)
        in_ordem(no->esq);
     printf("[%d]",no->info);
     if(no->dir!=NULL)
        in_ordem(no->dir);
  }else
      printf("\n\tA arvore esta vazia!\n"); 
}
/*************************************************/
/* PRE_ORDEM */
void pre_ordem(no_arv no){
  if (no!=NULL){
     printf("[%d]",no->info); 
     if(no->esq!=NULL)
        pre_ordem(no->esq);
     if(no->dir!=NULL)
        pre_ordem(no->dir);
  }else
      printf("\n\tA arvore esta vazia!\n");  
}
/*************************************************/
/* POS_ORDEM */
void pos_ordem(no_arv no){
  if (no!=NULL){
     if(no->esq!=NULL)
        pos_ordem(no->esq);
     if(no->dir!=NULL)
        pos_ordem(no->dir);
     printf("[%d]",no->info);  
  }else
      printf("\n\tA arvore esta vazia!\n");

}
/*************************************************/
/* MOSTRAR (PRE_ORDEM) */
void mostrar(no_arv no){
     static int cont=0;
     if(no==NULL)
       printf("\nEsta vazia\n");
     else
       printf("[%d] , Altura: %d ",no->info,no->altura);
     if(no->esq!=NULL){
        printf("\n\tEsquerda:");     
        mostrar(no->esq);
     }
     if(no->dir!=NULL){
        printf("\n\tDireita:");
        mostrar(no->dir);
     }
     printf("\nVoltando um nivel...");
}
/*************************************************/
/* MOSTRAR ARVORE*/
void mostrar_arvore(no_arv no){
  if (no!=NULL){
    printf("\n***********************************");
    printf("\n******* Caminho da arvore *********");
    printf("\n***********************************\n\tRaiz:");
    mostrar(no);
    printf("\n***********************************\n");
  }else
      printf("\n\tA arvore esta vazia!\n");  
}
/*************************************************/
/* MENU */
void menu(){
  printf("\n\t##########################################");
  printf("\n\t##  Estruturas de Dados II ##");   
  printf("\n\t## Arvore Binaria  - AVL                ##");   
  printf("\n\t##                        ##");   
  printf("\n\t##########################################");
  printf("\n\t##  OPCOES ");
  printf("\n\t## 1 - Inserir 10 elementos.");
  printf("\n\t## 2 - Inserir 1 elemento.");
  printf("\n\t## 3 - Mostrar arvore. (PRE-ORDEM)");
  printf("\n\t## 4 - Buscar elemento.");
  printf("\n\t## 5 - Excluir elemento.");
  printf("\n\t## 6 - Percurso IN-ORDEM.");
  printf("\n\t## 7 - Percurso PRE-ORDEM.");
  printf("\n\t## 8 - Percurso POS-ORDEM.");
  printf("\n\t## 9 - Destruir arvore.");  
  printf("\n\t## 0 - Sair.");
  printf("\n\t##########################################\n");  
}
/****************************************************/
/* MAIN */
int main(){
    no_arv raiz=NULL;
    int op,i,x;
    //carrega_arvore(&raiz);
    do{
         menu();
         printf("\n\tOpcao: ");
         scanf("%d",&op);
         switch(op){
               case 1:
                    for(i=0;i<10;i++){
                      printf("\n\tNovo elemento(inteiro):");
                      scanf(" %d",&x); 
                      insere(&raiz, x);
                    }
               break;
               case 2:
                    printf("\n\tNovo elemento(inteiro):");
                    scanf(" %d",&x);
                    insere(&raiz, x);
               break;
               case 3:
                    mostrar_arvore(raiz);
               break;
               case 4:
                    printf("\n\tElemento procurado: ");
                    scanf(" %d",&x); 
    				if (busca(raiz,x)==NULL)
                       printf("\n\tEste elemento nao esta na arvore!\n");
               break;
               case 5:
                    printf("\n\tElemento a ser removido: ");
                    scanf(" %d",&x);
                    if (exclui(&raiz,x))
                       printf("\n\tElemento foi excluido.");
                    else
                       printf("\n\tEste elemento nao esta na arvore!");                                        
                    verifica_avl(&raiz);
               break; 
               case 6:
                    in_ordem(raiz);          
               break;
               case 7:
                    pre_ordem(raiz);
               break;
               case 8:
                    pos_ordem(raiz);
               break;                                             
               case 9:
                    printf("\n\n\tDestruindo arvore...\n\t");  
                    raiz=destruir_arvore(&raiz);
               break;               
               case 0:break;              
               default: printf("\n\tOpcao invalida."); break;
        }
        printf("\n\n\t");        
        system("pause");
        system("cls");
   	}while (op!=0);

return 0;
}

Notícias, artigos e o maior fórum brasileiro sobre Java