Bom dia, estou com um problema que creio que seja simples:
Possuo uma lista, e preciso criar um método que altere de posição o primeiro elemento com o segundo, mas não estou conseguindo entender a lógica para fazer isso.
Preciso criar o método na classe descrita abaixo, o método precisa ser public boolean fazerTroca()
Se alguém puder me dar uma luz…agradeço.
public class List {
private Node firstNode;
private Node lastNode;
private String name;
public List() {
this( "list" );
}
public List( String listName ) {
name = listName;
firstNode = lastNode = null;
}
public Node getFirst(){
return firstNode;
}
public Node getLast(){
return lastNode;
}
public void insertAtFront( Object insertItem ) {
if ( isEmpty() )
firstNode = lastNode = new Node( insertItem );
else
firstNode = new Node( insertItem, firstNode );
}
public void insertAtBack( Object insertItem ) {
if ( isEmpty() )
firstNode = lastNode = new Node( insertItem );
else {
lastNode.setNext (new Node( insertItem ));
lastNode = lastNode.getNext();
}
}
public Object removeFromFront() throws EmptyListException {
if ( isEmpty() )
throw new EmptyListException( name );
Object removedItem = firstNode.getData();
if ( firstNode == lastNode )
firstNode = lastNode = null;
else
firstNode = firstNode.getNext();
return removedItem;
}
public Object removeFromBack() throws EmptyListException {
if ( isEmpty() )
Object removedItem = lastNode.getData();
if ( firstNode == lastNode )
firstNode = lastNode = null;
else {
Node current = firstNode;
while ( current.getNext() != lastNode )
current = current.getNext();
lastNode = current;
current.setNext(null);
}
return removedItem;
}
public boolean isEmpty() {
return firstNode == null; // return true if List is empty
}
public void print() {
if ( isEmpty() ) {
System.out.println( "Empty " + name );
return;
}
System.out.print( "The " + name + " is: " );
Node current = firstNode;
while ( current != null ) {
System.out.print( current.getData().toString() + " " );
current = current.getNext();
}
System.out.println( "\n" );
}
}
Pelo código imagino que seja um Lista Simplesmente Encadeada (Simply Linked List). Então os nodes só aponta para o próximo. Considerando isso um método que altera a posição do primeiro com o do segundo seria assim:
public boolean fazerTroca() {
if(isEmpty()) {
System.out.println("A lista está vazia");
return false;
}
if (firstNode == null || firstNode.getNext() == null) {
System.out.println("Quantidade de elementos insuficientes para esta operação");
return false;
}
// Exemplo Lista: { (10) -> (20) -> (30) }
Node nodeTemporario = firstNode.getNext(); // o elemento '20'
firstNode.setNext(firstNode.getNext().getNext()); // o próximo do '10' vira o '30'
nodeTemporario.setNext(firstNode); // o próximo do '20' vira o '10': (20) -> (10) -> (30)
firstNode = nodeTemporario; // atualiza a variável pra apontar pro '20'
return true;
}
Ah, saquei, cara.
E seguinte, isso eu considero alteração entre o primeiro e o segundo, caso precise ser feito alteração entre o terceiro e quarto, pela lógica eu precisaria por um contador, para que o programa contabilize a hora que ele chegar no elemento que eu espero…só que minha lógica não ta funcionando…
Seria algo do tipo:
public boolean troca_ter_quarto(){
if(isEmpty()){
System.out.println("A lista está vazia");
return false;
}
do{
int index = 0;
index++;
if(index == 3) {
firstNode.setNext(firstNode.getNext().getNext().getNext());
nodeTemporario.setNext(firstNode);
firstNode = nodeTemporario;
}
} while (firstNode != null);
return true;
}
Trocar o terceiro node pelo quarto node ficaria assim:
public boolean terceiroPorQuarto() {
if(isEmpty()) {
System.out.println("A lista está vazia");
return false;
}
int contador = 0;
int destino = 2; // eu quero chegar no TERCEIRO node
Node terceiroNode = firstNode; // tem que começar pelo primeiro
Node antesDoTerceiro = null; // pra poder trocar o NODE 3 com o NODE 4 preciso também do NODE 2
while (contador != destino) {
antesDoTerceiro = terceiroNode;
terceiroNode = terceiroNode.getNext();
if (terceiroNode == null) {
System.out.println("Quantidade de elementos insuficientes para esta operação");
return false;
}
contador++;
}
trocarDoisNodesConsecutivos(antesDoTerceiro, terceiroNode);
return true;
}
private void trocarDoisNodesConsecutivos(Node anteriorEsquerda, Node esquerda) {
if (anteriorEsquerda.getNext() != esquerda) {
throw new InvalidParameterException("Este método só consegue trocar a posição de dois nodes consecutivos");
}
// Exemplo: '10' -> '20' -> '30' -> '40' -> '50'
Node direita = esquerda.getNext(); // 'direita' é o quarto node '40'
anteriorEsquerda.setNext(esquerda.getNext()); // o próximo do '20' vira o '40'
esquerda.setNext(esquerda.getNext().getNext()); // o próximo do '30' vira o node '50'
direita.setNext(esquerda); // o próximo do '40' vira '30'
// Resultado: '10' -> '20' -> '40' -> '30' -> '50'
}
Criei um método auxiliar trocarDoisNodesConsecutivos() pra melhorar a legibilidade do método principal.
Espero que tenha conseguido entender. Pode perguntar algo se tiver ficado com dúvida.
Cara, eu só não entendi por quê preciso começar com 2 aqui…
De resto eu compreendi tudo.
É 2 porque eu comecei contando do 0, que é o padrão em programação.
0 -> primeiro
1 -> segundo
2 -> terceiro
Mas se quiser poderia ter feito dessa forma e funciona do mesmo jeito:
int contador = 1;
int destino = 3; // eu quero chegar no TERCEIRO node
E outra coisa que não tem a ver com o algoritmo em si, mas que acho relevante comentar: troca_ter_quarto() é um nome um pouco estranho pra um nome de método no Java. O padrão é o formato Camel Case, como por exemplo: trocaTerQuatro().
Beleza, cara.
Consegui tirar todas as dúvidas.
Agradeço a atenção.
