Lista dinamica - trocar posicao [RESOLVIDO]

Programação Java
#1

boa noite

gostaria de saber por favor como faço para realizar a troca de 2 elementos criados dinamicamente de estrutura…

	public void trocarElementos(Object m, Object n) {

		Celula elemento1 = procurarElemento(m);
		Celula elemento2 = procurarElemento(n);

		if ((elemento1 == null) || (elemento2 == null)) {
			throw new IllegalArgumentException("Os valores informados não contêm no arranjo");
		}

		Celula aux = elemento1;
		elemento1 = elemento2;
		elemento2 = aux;
	}

cheguei a efetuar esse código mas acredito que eu esteja errado pelo fato de estar passando a referencia de um objeto de forma errada…

como eu poderia refazer este código ou alguém poderia me indicar algo para ler, para efetuar a trocar entre 2 objetos em uma lista encadeada simples…

#2

Para trocar 2 elementos em uma lista encadeada, você precisa mexer diretamente na estrutura que representa a lista.
Esse código que você mostrou não faz isso, nem tem como fazer isso.

#3

Você tem o código da sua lista encadeada? (Obviamente isso é lição de casa, já que existe uma classe java.util.LinkedList<> que é uma lista encadeada. )

#4

fiz a lista ligada sem usar a api java

package listaDinamica;

public class ListaDinamica {

	private Celula primeiro, ultimo;

	public ListaDinamica() {
		primeiro = new Celula();
		ultimo = primeiro;
		primeiro.setProx(null);
	}

	public void inserirPrimeiroElemento(Object elementoNovo) {
		Celula primeiroElemento = primeiro;
		Celula novoElemento = new Celula();
		novoElemento.setElemento(elementoNovo);
		novoElemento.setProx(null);
		primeiroElemento.setProx(novoElemento);
		ultimo = novoElemento;

	}

	public void inserirEntreElemento(Object elementoNovo,
			Celula elementoAnterior) {
		Celula novoElemento = new Celula();
		novoElemento.setElemento(elementoNovo);
		novoElemento.setProx(elementoAnterior.getProx());
		elementoAnterior.setProx(novoElemento);
	}

	public void inserirUltimoElemento(Object elementoNovo) {
		Celula novoElemento = new Celula();
		novoElemento.setElemento(elementoNovo);
		novoElemento.setProx(null);
		ultimo.setProx(novoElemento);
		ultimo = novoElemento;
	}

	public Celula procurarElemento(Object elementoProcurado) {

		Celula atual = primeiro.getProx();

		while (atual != null) {
			if (atual.getElemento().equals(elementoProcurado)) {
				return atual;
			}
			atual = atual.getProx();
		}
		throw new IllegalArgumentException("Celula não encontrada");
	}

	public Celula procurarElementoAnterior(Object elementoProcurado) {

		Celula atual = procurarElemento(elementoProcurado);
		Celula anterior = primeiro;

		while (atual != null) {
			if (atual.getElemento().equals(anterior.getProx())) {
				return atual;
			}
		}
		throw new IllegalArgumentException("Celula anterior não encontrada");
	}

	public void trocarElementos(Object m, Object n) {

		Celula elemento1 = procurarElemento(m);
		Celula elemento2 = procurarElemento(n);

		if ((elemento1 == null) || (elemento2 == null)) {
			throw new IllegalArgumentException("Os valores informados não contêm no arranjo");
		}

		Celula aux = elemento1;
		elemento1 = elemento2;
		elemento2 = aux;
	}

	public void mostrarLista() {

		Celula atual = primeiro.getProx();

		while (atual != null) {
			System.out.println(atual.getElemento());
			atual = atual.getProx();
		}
	}

	public boolean listaVazia() {
		return primeiro == ultimo;
	}

	public int tamanhoLista() {

		int contador = 0;
		Celula atual = primeiro.getProx();

		while (atual != null) {
			contador++;
			atual = atual.getProx();
		}
		return contador;
	}
}

foi assim q fiz meu codigo tem a classe celula

package listaDinamica;

public class Celula {

	private Object elemento;
	private Celula prox;

	public Object getElemento() {
		return elemento;
	}

	public void setElemento(Object elemento) {
		this.elemento = elemento;
	}

	public Celula getProx() {
		return prox;
	}

	public void setProx(Celula prox) {
		this.prox = prox;
	}

}
#5

Ache as 2 células (como você fez) e use getElemento() e setElemento() corretamente.

Algo como:

Celula celula1 = ...;
Celula celula2 = ...;
Object o1 = celula1.getElemento();
Object o2 = celula2.getElemento();
celula1.setElemento (o2);
celula2.setElemento (o1);

Acho que você deve ter entendido a idéia.

#6

A propósito, você deve ter visto que andar sobre uma lista simplesmente ligada (que é o que você fez) é horrível, porque para pegar o elemento anterior você tem de percorrer a lista inteira e voltar um para trás. Que tal ter uma lista duplamente ligada?

#7

kkkkkk, cara esse é o proposito do exercício…

utilizar lista simplesmente encadeada

#8

[quote=entanglement]Ache as 2 células (como você fez) e use getElemento() e setElemento() corretamente.

Algo como:

Celula celula1 = ...;
Celula celula2 = ...;
Object o1 = celula1.getElemento();
Object o2 = celula2.getElemento();
celula1.setElemento (o2);
celula2.setElemento (o1);

Acho que você deve ter entendido a idéia. [/quote]

estou passando a referencia diretamente ao objeto…

#9

Eu pus os “…” para ver se você pensa um pouco e completa com o que é necessário. Você na verdade até já fez isso antes no código que você me mostrou, mas quero que você é que imagine o que vai naqueles “…”.

Outra forma, que o pessoal também pode usar, é mexer mais profundamente na lista ligada, e trabalhar com o campo “prox” de cada célula. Obviamente, nesse caso você precisa fazer um desenho e ver que tipos de mudanças você precisa fazer.

#10

Não se esqueça: em Java, não é possível passar uma referência para um objeto “por referência”. Java não é C#, em C# você poderia criar um método assim:

object o1 = new string("bla");
object o2 = new string("ble");
swap (ref o1, ref o2);
...
Console.WriteLine (o1); // imprimir "ble"
Console.WriteLine (o2); // imprimir "bla"

Esse método “swap” não pode ser escrito em Java.

#11

[quote=entanglement]Não se esqueça: em Java, não é possível passar uma referência para um objeto “por referência”. Java não é C#, em C# você poderia criar um método assim:

object o1 = new string("bla");
object o2 = new string("ble");
swap (ref o1, ref o2);
...
Console.WriteLine (o1); // imprimir "ble"
Console.WriteLine (o2); // imprimir "bla"

Esse método “swap” não pode ser escrito em Java. [/quote]

eu sei, eu vi numas páginas, acho que é uma boa hora pra aprender melhor sobre esse assunto de trabalhar com referencia a objeto em Java.

#12

não entendi muito bem o que vc disse…

realmente cheguei a pensar em fazer deste modo sabe, mas tipo tenho que fazer uma logica para pensar se esta em primeiro, ultimo coisas do tipo…

na hora de debugar o hashcode que aparece no Eclipse é um end de memoria?

Tem como ver?

Vlw

#13 
	public void trocarElementos(Object m, Object n) {

		Celula elemento1 = procurarElemento(m);
		Celula elemento2 = procurarElemento(n);

		if ((elemento1 == null) || (elemento2 == null)) {
			throw new IllegalArgumentException("Os valores informados não contêm no arranjo");
		}

		m = elemento1.getElemento();
		n = elemento2.getElemento();
		
		elemento1.setElemento(n);
		elemento2.setElemento(m);
	}

eu fiz este código aqui e deu certo agora…

mas preciso estudar essa coisa de referencia de memoria em Java

porque eu vi uma coisa em um blog aonde o cara mostrava a diferença entre a passagem via parâmetro de método e recebendo dentro de uma variavel criada dentro do metodo…

vou verificar…

pois um colega ainda disse estar errado

#14

pessoal, obrigado pela ajuda, o codigo certo é esse…

vlw…

serve para lista dinâmica simples…

	public void trocarElementos(Object m, Object n) {

		Celula celula1 = procurarCelula(m);
		Celula celula2 = procurarCelula(n);

		Celula celulaAnterior1 = procurarCelulaAnterior(celula1);
		Celula celulaAnterior2 = procurarCelulaAnterior(celula2);

		if ((celulaAnterior1 == null) || (celulaAnterior2 == null)
				|| (celulaAnterior1.equals(celulaAnterior2))) {
			throw new IllegalArgumentException(
					"Os valores informados não contêm no arranjo");
		}
		
		celulaAnterior1.setProx(celula2);
		celulaAnterior2.setProx(celula1);
		
		celulaAnterior1 = celula1.getProx();
		celulaAnterior2 = celula2.getProx();
		
		celula1.setProx(celulaAnterior2);
		celula2.setProx(celulaAnterior1);
		
	}
1 curtida
#15