[resolvido] operaÇÕes com vetor

7 de junho de 2007 4 respostas

gpd38 7 de junho de 2007

Estou precisando de uma ajudinha.

Estava fazendo um codigo onde gostaria de colocar duas operações basicas que podem ser feitas com vetor: INTERSEÇÃO E UNIÃO.

Estou fazendo o mais basico possivel. Apenas com metodos e tal.
Depois eu faço elas com objeto, etc.

/*
   	 * Main
   	 */ 
       public static void main(String args[])
      {
         int A[], B[], C[];
         String str="";
         int tam, cont=0;
         boolean verificarA, verificarB;
         
         tam = Tamanho();//go to Line 09
      
      	// Vetor A
         str=" Criando e Preenchendo o Vetor A ";
         Mensagem(str);//go to Line 57
         A = CriaVetor(tam);//go to Line 19
         while(cont <= A.length-1)
         {
            A[cont] = PreencherVetor(cont);//go to Line 29
            cont++;  
         }
      	
      	// Vetor B
         str = " Criando e Preenchendo o Vetor B ";
         Mensagem(str);//go to Line 57
         cont = 0;//zera o contador para ser usado novamente
         B = CriaVetor(tam);//go to Line 19
         while(cont <= A.length-1)
         {
            B[cont] = PreencherVetor(cont);//go to Line 29
            cont++;  
         }
      	
      	//Verificar vetores
         verificarA = Crescente(A);//go to Line 38
         if(verificarA == true)
            JOptionPane.showMessageDialog(null," O Vetor A não está em ordem crescente !");
         else
            JOptionPane.showMessageDialog(null," O Vetor A está em ordem crescente !");
      
         verificarB = Crescente(B);//go to Line 38
         if(verificarB == true)
            JOptionPane.showMessageDialog(null," O Vetor B não está em ordem crescente !");
         else
            JOptionPane.showMessageDialog(null," O Vetor B está em ordem crescente !");
      
         //Uniao de Vetores


        
        //Interseção de Vetores
      
           
          
         MostrarVetores(A,B,C);//go to Line 65
         
      	//forçar a finalização do Programa
         System.exit(0);
      
      }//fim main

import javax.swing.*;
   //import java.io.*;

    class MelhorarLista12
   {
   	/*
   	 * Metodo Tamanho
   	 */
       public static int Tamanho()
      {
         int tamanho = Integer.parseInt(JOptionPane.showInputDialog(" Entre com o tamanho do vetor "));
         return(tamanho);
      }//fim metodo tamanho
   
   	/*
   	 * Metodo Cria Vetor
   	 * @param tam - tamanho do vetor
   	 */
       public static int[] CriaVetor(int tam)
      {
         int vet[] = new int[tam];
         return(vet);
      }//Fim Metodo CriaVetor
      
   	/*
   	 * Metodo PreencherVetor
   	 * @param cont - posição do proximo numero
   	 */
       public static int PreencherVetor(int cont)
      {
         int num = Integer.parseInt(JOptionPane.showInputDialog(" Entre com o "+(cont+1)+"º elemento do vetor "));
         return(num);
      }//fim Metodo PreencheVetor
   	
   	/*
   	 * Metodo Crescente
   	 */
       public static boolean Crescente(int X[])
      {
         int menor = X[0];
         boolean trocou = false;
      	
         for(int j=0;j<X.length;j++)
            if(menor > X[j]){
               menor = X[j];
               trocou = true;
               return(trocou);
            }
               
         return(trocou);
         
      }//fim Metodo Crescente
      
    /**
     *
     */
       public static void Mensagem(String msg)
      {
         System.out.println(msg);
      }//fim metodo Mensagem
   
    /**
     *
     */
       public static void MostrarVetores(int A[], int B[], int C[])
      {
         Mensagem("Vetor A:");//go to Line 57
         for(int x=0; x< A.length; x++)
            System.out.print(A[x]+" ");
         Mensagem("Vetor B:");//go to Line 57
         for(int x=0; x< B.length; x++)
            System.out.print(B[x]+" ");
         Mensagem("Vetor Uniao:");//go to Line 57
         for(int x=0; x< C.length; x++)
            System.out.print(C[x]+" ");
            
      }//fim metodo Mensagem
   
    /**
     *
     */
       public static int[] Copia(int A[], int tam)
      {
         int vet[] = CriaVetor(tam);//go to Line 19
         for(int k=0 ; k<tam ; k++)
            vet[k] = A[k];
         return(vet);
      }//fim metodo Copia

       public static int[] Uniao(int a[],int b[]int tam)
      {
      int c[] = new int[tam*2];



      return c;
      }//fim metodo uniao

      public static int[] Intersecao(int a[], int b[], int tam)
      {
        int c[] = new int[tam*2];



      return c;
      }//fim metodo interseção

}

Alguem pode me ajudar a fazer estes metodos, pois não estou conseguindo!!!

4 Respostas

sergiotaborda 7 de jun. de 2007

gpd38:
Estou precisando de uma ajudinha.

Estava fazendo um codigo onde gostaria de colocar duas operações basicas que podem ser feitas com vetor: INTERSEÇÃO E UNIÃO.

Já começa torto… essas operações não podem ser feitas com vetores, mas sim com conjuntos. Claro que vc pode representar um conjunto como um array (que é traduzido como “vetor” para português , mas cuja tradução mais literal seria coleção/organização).

OOP trata de traduzir conceitos do mundo real para objetos, por isso é importante diferenciar array de vetor e conjunto neste contexto.

Se união e interseção são feitas com cojuntos, o que ha em java que seja um conjunto (no sentido matemático do termo) ? Todas as subclasses de Set

Set já contém as operações que vc precisa.

Set<Integer> A = new HashSet<Integer>();
A.add(2);
A.add(3);
A.add(4);

Set<Integer> B = new HashSet<Integer>();
B.add(1);
B.add(5);
B.add(4);

A.addAll(B)  // União

A.retainAll(B) // intersecção

Talvez queira algo mais matemático como

Set U = A.union(B);
Set I = A.intersect(B);

Nesse caso vc pode criar uma classe chamada meupacote.Set que tenhas essas operações. Por baixo dos panos use um java.util.Set em vez de um array. Será muiiiito mais simples de implementar sua classe.

gpd38 7 de jun. de 2007

Então Cancelem a minha ultima postagem
Como eufaço agora a uniao e a interseção neste codigo

import javax.swing.*;
   import java.io.*;
   import java.util.*;
   //###################################################################################################  
   /**
	 * Classe Lista12
	 */
    class ListaVetor
   {
      private Celula inicio,fim,sentinela;
      
     /**
      * Classe Celula
   	*/
       private static class Celula
      {
         public Celula prox;
         public int valor;
         
        /**
         * Construtor Celula
      	* @param valor - recebe um numero que será guardado posteriormente dentro de uma celula 
      	*/
          public Celula(int valor)
         {
            this.valor = valor;
            prox = null;
         }// Construtor Celula
         
         /**
      	 * Construtor Celula 
      	 * Construtor vazio, so inicializa o prox, pois nao recebe nada como parametro
      	 */
          public Celula()
         {
            prox = null;
         }// Construtor Celula
      }//fim classe Celula
   	
   //###################################################################################################  
   	/**
   	 * Construtor da ListaVetor
   	 */
       public ListaVetor()
      {
         fim = inicio = new Celula();
      }//fim construtor
   //###################################################################################################  
      /**
   	 * Metodo Quantidade
   	 * @return - retorna um valor digitado pelo usuario para a posição X do vetor C
   	 * @param x - posição onde o numero sera colocado
   	 * @param c - Variavel que indica qual vetor esta sendo preenchido
   	 */
       public static int Quantidade(String msg)
      {
         return(Integer.parseInt(JOptionPane.showInputDialog(msg)));
      }//fim metodo LeTeclado
   //###################################################################################################  
      /**
   	 * Metodo LeTeclado
   	 * @return - retorna um valor digitado pelo usuario para a posição X do vetor C
   	 * @param x - posição onde o numero sera colocado
   	 * @param c - Variavel que indica qual vetor esta sendo preenchido
   	 */
       public int LeTeclado(int x,char c)
      {
         return(Integer.parseInt(JOptionPane.showInputDialog(" Digite o "+(x+1)+"º elemento para o Vetor "+c)));
      }//fim metodo LeTeclado
   //###################################################################################################  
      /**
   	 * Metodo insere
   	 * @param num - recebe um numero e insere-o em uma celula.
   	 * Depois pega a celula e a insere no Vetor
   	 */
       public void insere (int num)
      {
         this.fim.prox = new Celula (num);
         this.fim = this.fim.prox;
         this.fim.valor = num;
         this.fim.prox = new Celula();
      }//fim metodo insere
   //###################################################################################################  
      /**
   	 * Metodo Tamanho
   	 * @return tam - retorna o tamanho do Vetor
   	 */
       public int tamanho()
      {
         int tam=0;
         Celula conta = inicio;
         while(conta != null)
         {
            conta = conta.prox;
            tam++;
         }
         return(tam);
      }//fim metodo tamanho
   //###################################################################################################  
   	 /**
   	  * Metodo mostrar
   	  * Cria uma Referencia e mostra o Vetor todo atraves desta nova referencia
   	  */
       public void Mostrar(){
         if(inicio == null)
            //System.out.println("Vetor vazio");
            throw new RuntimeException(" Vetor vazio ");
            
         Celula aux = inicio;
         while(aux != null){
            System.out.print(aux.valor+" ");
            aux = aux.prox;
         }
      }//fim metodo mostrar
   //###################################################################################################  
      /**
   	 * Metodo estaVazia
   	 * @return boolean - retorna verdadeiro, caso o Vetor esteja vazio
   	 */
       public boolean estaVazia()
      {
         return(inicio == fim);
      }//fim metodo estaVazia
   //###################################################################################################  
      /**
   	 * Metodo Localizar
   	 * @param valor - recebe um numero que devera ser encontrado no Vetor.
   	 * @return auxpos  - retorna a posição anterior ao elemento, pois a celula
   	 *                   em que o elemento esta será excluida
   	 */	 
       public Celula Localizar(int valor)
      {
         Celula auxprox, auxpos;
         auxprox = inicio.prox;
         auxpos = inicio;
       
         while(auxprox != null && auxprox.valor != valor)
         {
            auxpos = auxprox;
            auxprox = auxprox.prox;
         }
         
         if(auxprox == null || this.estaVazia())
         {
            return(null);
         }
         return(auxpos);
      }//fim metodo localizar
   //###################################################################################################  
     /**
   	 * Metodo retiraApos
   	 * @param pos - recebe a posição(celula) que sera retirada do Vetor
   	 * @return v - retorna o valor que estava naquela celula
   	 */
       public int retiraApos(Celula pos)
      {
         if(pos == null || pos.prox == null || estaVazia())
         {
            throw new RuntimeException("Erro: Esta Vazio");
         }
         
         int v = pos.prox.valor;
         pos.prox = pos.prox.prox;
       
         if(pos.prox == null)
         {
            fim = pos;
         }
         return v;
      }//fim metodo retiraApos
   //###################################################################################################  
   	/**
   	 * Metodo retiraPrimeiro
   	 * @return v - retorna o valor da primeira celula
   	 */
       public int retiraPrimeiro()
      {
         if(estaVazia())
         {
            throw new RuntimeException(" ERRO: Esta Vazio ! ");
         }
         
         Celula aux = inicio;
         Celula aux_p = aux.prox;
         int v = aux_p.valor;
         aux.prox = aux_p.prox;
       
         if(aux.prox == null)
         {
            fim = aux;
         }
         return v;
      }//fim metodo retiraPrimeiro
   //###################################################################################################  
      /**
   	 * Metodo Verificar
   	 * @param vetor - recebe um vetor para a verificação de estar em ordem crescente
   	 */
       public boolean Verificar(int vetor[])
      {
         boolean trocou = true;
               
         return(trocou);
         
      }//fim metodo Verifivar

   //###################################################################################################  
   	/**
   	 * Metodo Uniao
   	 */
       
   //###################################################################################################  
   	/**
   	 * Metodo Intersecao
   	 */
 
      
   //###################################################################################################  
   //########################################### MAIN ##################################################  
   //###################################################################################################  
   	/**
   	 * Metodo Main
   	 */
       public static void main(String args[])
      {
         ListaVetor VA = new ListaVetor();//cria primeiro vetor vazio
         ListaVetor VB = new ListaVetor();//cria segundo vetor vazio
         ListaVetor VC = new ListaVetor();//cria terceiro vetor vazio
         
         int parar,x=0;
         int guardar,i=0;
         char c;
       
      //########################################## Vetor A #############################################
         c='A';
         parar = Quantidade(" Numero de elementos do Vetor "+c);
         guardar = 0;
         System.out.println("\n Inserindo numeros no 1º Vetor ");
         //preencher o 1º Vetor
         while(x < parar)
         {
            guardar = VA.LeTeclado(x,c);//linha 62
            VA.insere(guardar);
            x++;
         }//fim while()
        
        //mostra o tamanho
         int h = VA.tamanho();System.out.print("\n Tamanho do 1º Vetor:  "+(h-2)+" \n ");
        //mostrar o 1º Vetor
         VA.Mostrar();System.out.print("\n");
        
      //########################################## Vetor B #############################################
         c = 'B';x = 0;
         parar = Quantidade(" Numero de elementos do Vetor "+c);
         guardar = 0;
         System.out.println("\n Inserindo numeros no 2º Vetor ");
         //preencher o 2º Vetor
         while(x < parar)
         {
            guardar = VB.LeTeclado(x,c);//linha 62
            VB.insere(guardar);
            x++;
         }//fim while()
        
        //mostra o tamanho
         int g = VB.tamanho();System.out.print("\n Tamanho do 1º Vetor:  "+(g-2)+" \n ");
        //mostrar o 2º Vetor
         VB.Mostrar();System.out.print("\n");
        
      //########################################## Vetor C #############################################
        //Uniao
        
        
        //Interseção
        
        
        
        //finalizar o Programa
         System.exit(0);
         
      }//fim main
   }//fim classe lista

Como eu faço agora

sergiotaborda 7 de jun. de 2007

O seu código é extremamente difícil de ler porque não segue numa dezena de conveções pelo que suspeito que não passa de um código para algum teste ou exercicio…

Vc tem uma lista encadeada e métodos para saber se um elemento está na lista (Localizar)

Crie primeiro um método que lhe retorne a primeira e um outro que retorne a ultima celula ,
Crie método que teste se uma celula é igual à outra e um que teste se a lista contém determinada celula. Não calcule o tamanho, crie uma variável interna e incremente cada vez que fizer uma inserção. Ai faça assim

Para a união [Editado]

Crie uma lista resultado vazia
Itere cada lista e adicione seus elementos na lista vazia.
retorne a lista resultado

Para a intersecção

determine qual a menor lista e a maior (compare os tamanhos)A intersecção sempe terá um tamanho menor ou igual à menor lista.
Crie uma lista resultado interna, vazia. Itere os itens da lista menor e verifique se estão contidos na maior.
2.1 Se sim, adicione-os na lista de resultado.
Retorne a lista resultado.

gpd38 7 de jun. de 2007

Blz, Pelo menos é uma boa ideia. Vou tentar aqui , valeu

Criado 7 de junho de 2007

Ultima resposta 7 de jun. de 2007

Respostas 4

Participantes 2

4 Respostas

Topicos relacionados