Problem removing element from a linked list

Question

Problem removing element from a linked list

Navigation

#1 by (4 votes)
#2 by (0 votes)

3

I'm implementing a threaded list in Java. However, the remove function is causing me some problems, but specifically the remove part in the middle of the list. My list consists only of an integer field with a note.

public void remove(int nota)
{
    Aluno ante = null;
    Aluno posi = this.first;

    while(posi.getNota() != nota)
    {
        ante = posi;
        posi = posi.getProximo();
    }


    if(posi == null)
    {
        System.out.println("Valor não encontrado");
        return;
    }

    if(posi == this.first)
    {
        this.first = posi.getProximo();
        posi = null;
    }
    else if(posi.getProximo() == null)
    {
        ante.setProximo(null);
        posi = null;
    }
    else
    {
        ante.setProximo(posi);
        posi = null;
    }
    this.tamLista--;
}

Where is the error? I can not identify.

java lista-encadeada

asked by anonymous 20.11.2015 / 03:08

2 answers

0

Friend, it is not possible to do some operations on lists at run time. For example, if the list is within "for" chained you can not remove it. You have to change the logic to get to your goal. Can you post the log with the error to check it out?

21.11.2015 / 17:21

How to change primary key that references foreign key for auto increment How to inject a variable into a page that was required by a function

score 4 · Accepted Answer

A simpler way is to use a recursive method. This way, you will pass as parameter the first element of the list and the note that you want to look for to remove. An example:

Aluno removeAluno(Aluno aluno,int nota){

  if(aluno != null){

      // Se o aluno atual for o aluno que você deseja remover, ele é substituido pelo aluno seguinte
     if(aluno.getNota() == nota){

      aluno = aluno.getProx();

     // Se não for, a função é chamada novamente, passando o próximo aluno como parâmetro
    }else{

        aluno.getProx() = removeAluno(aluno.getProx(), nota);
    }
  }

  return aluno;
}

Example run:

List: Student (note: 10) - > Student (note: 8) - > Student (note: 6) - > Student (note: 5)

Search for note == 6

Execution:

Aluno(nota:10) = removeAluno( Aluno(nota:10), 6)

6 == Aluno(nota:10).getNota() ---- > false

Aluno(nota:10).getProx() = removeAluno( Aluno(nota:8) , 6)

6 == Aluno(nota:8).getNota() ---- > false

Aluno(nota:8).getProx() = removeAluno( Aluno(nota:6) , 6)

6 == Aluno(nota:6).getNota() ---- > true

Aluno(nota:6) é substituído por Aluno(nota:5)

Now begins the recursion, Aluno(nota:5) that just replaced Aluno(nota:6) , is returned to the previous calls. Doing from the front:

Aluno(nota:8).getProx() = Aluno(nota:5) that is: Aluno(nota:8)-> Aluno(nota:5)

Aluno(nota:10).getProx() = Aluno(nota:8) that is: Aluno(nota:10)-> Aluno(nota:8)

Aluno(nota:10) = Aluno(nota:10) that is, the first element of the list remains Student (note: 10)

If we look at the list now, it will look like this:

List: Student (note: 10) - > Student (note: 8) - > Student (note: 5)