LinkedList ajuda

Programação Java
#1

Boas
Estou a iniciar-me a trabalhar com as LinkedList,e gostava de saber como posso remover duas posiçoes da lista,e saber quais os elemntos que estao antes e depois.
Obrigado

#2

Já vi alguns topicos sobre o assunto aqui no forum…

http://www.guj.com.br/jforum.java?module=search&action=search&search_keywords=LinkedList&match_type=all&search_forum=&sort_by=relevance

#3

Para remover use o método remove.
Antes e depois do que?

#4

[quote=jlity]Boas
Estou a iniciar-me a trabalhar com as LinkedList,e gostava de saber como posso remover duas posiçoes da lista,e saber quais os elemntos que estao antes e depois.
Obrigado[/quote]

ola , eh o seguinte… veja o exemplo:

LinkedList lista = new LinkedList();

lista.add();
lista.addFirst();
lista.addLast();
lista.remosve(int);
lista.removeFirst();
lista.removeLast();

#5

E como posso saber qual o objecto que está a seguir ao objecto que removi??

#6

Se você removeu o primeiro, o próximo, se houver, é o primeiro.

Se você removeu o n, o próximo, se houver, é o n.

Se você removeu o último, não tem próximo.

#7

Visto que ninguem percebeu aqui vai o que pretendo fazer :stuck_out_tongue:

Em um metodo recebo como parametros a cabeça de uma lista e 2 numeros inteiros que vao corresponder a posiçoes da lista,e pretendo remover todos os objectos entre essas duas posiçoes tal como eles proprios. returnando a nova cabeça da lista.
Se alguem me puder dar uma ajudinha ae

#8

nesse caso é melhor vc usar uma ArrayList(), que vc vai direto no índice dos elementos que quer remover…

#9

O problema é que é passado como parametro a cabeça de uma linkedlist

#10

Você está resolvendo um exercício ou trabalhando num programa de verdade?

Pois é estranho receber só cabeça de uma lista, não há vantagem alguma nessa implementação.

#11

é mesmo um exercicio

#12

[quote=jlity]Em um metodo recebo como parametros a cabeça de uma lista e 2 numeros inteiros que vao corresponder a posiçoes da lista,e pretendo remover todos os objectos entre essas duas posiçoes tal como eles proprios. returnando a nova cabeça da lista.
Se alguem me puder dar uma ajudinha ae[/quote]

Use para isso um listIterator. Você deve iterar de trás para frente na lista, já que a remoção de um objeto alterará os índices dos posteriores.

Aqui vai um código de exemplo:

[code]import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

public class Main {
public static void remove(List list, int begin, int end) {
if (end > list.size()) {
throw new IllegalArgumentException(“End (” + end + “) maior que a lista (” + list.size() + “)!”);
}

    if (begin > end) {
        throw new IllegalArgumentException("Begin deve ser menor ou igual ao end!");
    }

    if (begin < 0) {
        throw new IllegalArgumentException("Begin deve ser maior ou igual a zero");
    }
    
    //Pegamos um iterador posicionado no fim.
    ListIterator<T> it = list.listIterator(end+1);
    while (it.hasPrevious()) {
        //Já chegou antes do início? Hora de parar
        if (it.previousIndex() < begin)
            break;
        
        //Iteramos para trás e removemos.
        it.previous();
        it.remove();
    }
}

public static void main(String[] args) {
    List<String> teste = new ArrayList<String>(Arrays.asList("Banana", "laranja", "limão", "maçã", "pêra", "jaca"));
    remove(teste, 1, 3); //Remove laranja, limão e maçã
    System.out.println(teste);
}

}[/code]

#13

No caso de ter que percorrer uma linked list pura, pela cabeça, faça o seguinte:

[code]public void remove(Node cabeca, int begin, int end) {
//mesmas validações anteriores
int currentIndex = 0;
Node currentNode = cabeca;

//vamos andar até a posição a ser removida
while (currentIndex <= end) {
if (currentIndex < begin) { //Ainda não chegou a hora de remover?
currentNode = currentNode.next; //Então pula pro próximo
} else { //Se está na hora, remove e considera que andou na lista.
remove(currentNode); //É importante que esse método posicione a lista no nextNode.
currentNode++;
}
}
}[/code]

Esse método funciona para listas duplamente ou simplesmente encadeadas.

#14