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!!!
Estava fazendo um codigo onde gostaria de colocar duas operações basicas que podem ser feitas com vetor: INTERSEÇÃO E UNIÃO.
[/quote]
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.
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
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.