How to order double chained list without affecting the original list?

Question

How to order double chained list without affecting the original list?

Asked 5 years, 8 months ago

Viewed 384 times

1

Hello!

So far, I have been able to implement all the methods on the list, including the sort method. However, the problem is that when ordering, even creating a new list and making it receive the list that should be ordered as parameter, when ordering, all two lists are affected.

I imagine this is happening because I am passing the reference (address in memory) of the original list, would that be it? If this is it, how to get around?

I’ll post more relevant code snippets in case you miss any more just let you know that I edit.

Calling the Methods on Main:

            case 6: 
                EstruturaDeDados.MostrarCandidatos(LDE, "Relatório Por Ordem de Inscrição");
                break;
            case 7: 
                EstruturaDeDados.ClassificarCandidados(LDE);
                break;
            default: JOptionPane.showMessageDialog(null,"Opção inválida!","Advertência",JOptionPane.WARNING_MESSAGE);

Method responsible for displaying any list passed as parameter:

public static void MostrarCandidatos(EstruturaDeDados _LDE, String tela) 
{
    No UA = new No();               // Usuário Atual  
    String relatorio = "";              // Relatório
    String linha_divisora = "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n";
    int c = 0;                      // Contador
    UA = _LDE.getInicioDaLista();
    String tituloDasTelas = "Sistema de Classificação " + tela;

    if (!_LDE.isEmpty()) {
        relatorio += linha_divisora;
        relatorio += "                                                                                                                                                  Relatório de Candidatos                   \n";
        relatorio += linha_divisora;
        relatorio += "|                   Posição                   |                    Código                   |                   Nome                   |                   Nascimento                   |                   Pontuação                   |                   Renda                   |\n";
        relatorio += linha_divisora;

        while (UA != null) 
        {                
              relatorio +="|"+StringUtils.center(Integer.toString(c), 52)+
                      "|"+StringUtils.center(Integer.toString(UA.getDadosDoCandidato().getCodCandidato()), 50)+
                      "|"+StringUtils.center(" "+UA.getDadosDoCandidato().getNomeCandidato(), 40)+
                      "|"+StringUtils.center(UA.getDadosDoCandidato().getDataNascimentoCandidato(), 52)+
                      "|"+StringUtils.center(Double.toString(UA.getDadosDoCandidato().getPontuacaoCandidato()), 52)+
                      "|"+StringUtils.center(Double.toString(UA.getDadosDoCandidato().getRendaCandidato()), 45)+"|\n";

                       UA = UA.getProximo();
                       c++;
        }
        relatorio += linha_divisora;
    }

    if(!relatorio.equals(""))
        JOptionPane.showMessageDialog(null,relatorio,tituloDasTelas,JOptionPane.PLAIN_MESSAGE);
    else
        JOptionPane.showMessageDialog(null,"Não existe(m) usuário(s) cadastrado(s)!",tituloDasTelas,JOptionPane.PLAIN_MESSAGE);

}

Method responsible for carrying out the ordering:

public static void ClassificarCandidados(EstruturaDeDados LDEClassificados) 
{

    Candidato Candidato_AUX;
    No UA = LDEClassificados.getInicioDaLista();
    No PU = LDEClassificados.getInicioDaLista().getProximo();

    int length = LDEClassificados.getQuantidadeCandidatos();

    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - (i+1); j++) {
            if (UA.getDadosDoCandidato().getPontuacaoCandidato() > PU.getDadosDoCandidato().getPontuacaoCandidato()) {

                Candidato_AUX = UA.getDadosDoCandidato();
                UA.setDadosDoCandidato(PU.getDadosDoCandidato());
                PU.setDadosDoCandidato(Candidato_AUX);
            }
             UA = UA.getProximo();
             PU = PU.getProximo();
        }
        UA = LDEClassificados.getInicioDaLista();
        PU = LDEClassificados.getInicioDaLista().getProximo();
    }
    EstruturaDeDados.MostrarCandidatos(LDEClassificados, "Relatório Por Ordem de Pontuação");

}

Class Data Structure:

public class EstruturaDeDados {

/*-----------------------------------
         ATRIBUTOS DA CLASSE
  -----------------------------------*/


private No inicio_lista;
private int quantidade_candidatos;
private No final_lista;
private EstruturaDeDados LDEClassificados, LDESuplentes;
/*-----------------------------------
         CONSTRUTOR DA CLASSE
  -----------------------------------*/



/*-----------------------------------
        MÉTODOS get E set DA CLASSE
  -----------------------------------*/

public No getInicioDaLista()
{
    return inicio_lista;
}
public void setInicioDaLista(No _IL)
{
    inicio_lista = _IL;
}

public int getQuantidadeCandidatos()
{
    return quantidade_candidatos;
}
public void setQuantidadeCandidatos(int _QC)
{
    quantidade_candidatos = _QC;
}

public No getFinalDaLista()
{
    return final_lista;
}
public void setFinalDaLista(No _FL)
{
    final_lista = _FL;
}

/*-----------------------------------
           MÉTODOS DA CLASSE
  -----------------------------------*/
public boolean isEmpty()
{
    return this.getQuantidadeCandidatos() == 0;
}

public void InicializarLista()
{
    this.setInicioDaLista(null);
    this.setQuantidadeCandidatos(0);
    this.setFinalDaLista(null);
}

public boolean  InserirCandidato(int _p, int _cc, String _nc, String _dnc, double _pc, double _rm) 
{

    if (_p < 0 || _p > this.getQuantidadeCandidatos()) {
        return false;
    }
    else
    {
        No novoNo = new No(_cc, _nc, _dnc, _pc, _rm);

        // Caso 1 - Lista Vazia
        if (this.isEmpty()) 
        {
            this.setInicioDaLista(novoNo);
            this.setFinalDaLista(novoNo);
        }
        else
        {
            // Caso 2 - Posição = 0
            if (_p == 0) {

                // Novo nó aponta como próximo o nó contido no inicio da lista.
                novoNo.setProximo(this.getInicioDaLista());

                // Nó do inicio da lista passa a apontar como anterior o novo nó.
                this.getInicioDaLista().setAnterior(novoNo);

                // Lista recebe como inicio da lista o novo nó.
                this.setInicioDaLista(novoNo);
            }

            // Caso 3 - Posição = Quantidade de Usuários
            if (_p == this.getQuantidadeCandidatos()) {

                novoNo.setAnterior(this.getFinalDaLista());
                this.getFinalDaLista().setProximo(novoNo);
                this.setFinalDaLista(novoNo);
            }
            else
            {
                // Caso 4 - [Posição > 0] && [Posição < Quantidade de Usuários]

                // UA -> Usuário Atual
                // PU -> Próximo Usuário
                // C  -> Contador 

                No UA, PU;

                if (_p <= (this.getQuantidadeCandidatos()/2)) {

                    int C = 0;

                    UA = this.getInicioDaLista();
                    while (C < _p-1) {                            
                        UA = UA.getProximo();
                        C++;
                    }

                    PU = UA.getProximo();

                    UA.setProximo(novoNo);
                    PU.setAnterior(novoNo);

                    novoNo.setAnterior(UA);
                    novoNo.setProximo(PU);

                }
                else
                {
                    UA = this.getFinalDaLista();
                    int C = this.getQuantidadeCandidatos()-1;

                    while (C > _p) {                            
                        UA = UA.getAnterior();
                        C--;
                    }
                    PU = UA.getAnterior();

                    PU.setProximo(novoNo);
                    UA.setAnterior(novoNo);

                    novoNo.setAnterior(PU);
                    novoNo.setProximo(UA);
                }
            }
        }
        this.setQuantidadeCandidatos(this.getQuantidadeCandidatos()+1);
        return true;

    }
}

public boolean ExcluirCandidato(int _p) 
{

    if (_p < 0 && _p > this.getQuantidadeCandidatos()) {
        return false;
    }
    else{
        if (this.getQuantidadeCandidatos() == 1) {
            this.InicializarLista();
        }
        else
        {
            No UA; // Usuário Atual

            if (_p == 0) {

               UA = this.getInicioDaLista().getProximo();
               UA.setAnterior(null);

               this.getInicioDaLista().setProximo(null);
               this.setInicioDaLista(UA); 
            }
            else
            {
                if (_p == this.getQuantidadeCandidatos()-1) {

                    UA = this.getFinalDaLista().getAnterior();
                    UA.setProximo(null);

                    this.getFinalDaLista().setAnterior(null);
                    this.setFinalDaLista(UA);
                }
                else
                {
                    int C; // Contador
                    No PU;

                    if (_p <= (this.getQuantidadeCandidatos()/2)) {

                        C = 0;
                        UA = this.getInicioDaLista();

                        while(C < _p-1)
                        {
                            UA = UA.getProximo();
                            C++;
                        }

                        PU = UA.getProximo().getProximo();

                        UA.getProximo().setAnterior(null);
                        UA.getProximo().setProximo(null);

                        UA.setProximo(PU);
                        PU.setAnterior(UA);
                    }
                    else
                    {
                        C = this.getQuantidadeCandidatos()-1;
                        UA = this.getFinalDaLista();

                        while (C > _p) {                                
                            UA = UA.getAnterior();
                            C--;
                        }
                        PU = UA.getAnterior().getAnterior();

                        UA.getAnterior().setAnterior(null);
                        UA.getAnterior().setProximo(null);

                        UA.setAnterior(PU);
                        PU.setProximo(UA);
                    }
                }
            }
        }
    }
    this.setQuantidadeCandidatos(this.getQuantidadeCandidatos()-1);
    return true;
}

public No PesquisarCandidato(int _cdc) 
{
    No UA = this.getInicioDaLista();

    while (UA != null) {       

        if (UA.getDadosDoCandidato().getCodCandidato() == _cdc) 
            return UA;
            UA = UA.getProximo();

    }
    return null;
}

public static void MostrarCandidatos(EstruturaDeDados _LDE, String tela) 
{
    No UA = new No();               // Usuário Atual  
    String relatorio = "";              // Relatório
    String linha_divisora = "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n";
    int c = 0;                      // Contador
    UA = _LDE.getInicioDaLista();
    String tituloDasTelas = "Sistema de Classificação " + tela;

    if (!_LDE.isEmpty()) {
        relatorio += linha_divisora;
        relatorio += "                                                                                                                                                  Relatório de Candidatos                   \n";
        relatorio += linha_divisora;
        relatorio += "|                   Posição                   |                    Código                   |                   Nome                   |                   Nascimento                   |                   Pontuação                   |                   Renda                   |\n";
        relatorio += linha_divisora;

        while (UA != null) 
        {                
              relatorio +="|"+StringUtils.center(Integer.toString(c), 52)+
                      "|"+StringUtils.center(Integer.toString(UA.getDadosDoCandidato().getCodCandidato()), 50)+
                      "|"+StringUtils.center(" "+UA.getDadosDoCandidato().getNomeCandidato(), 40)+
                      "|"+StringUtils.center(UA.getDadosDoCandidato().getDataNascimentoCandidato(), 52)+
                      "|"+StringUtils.center(Double.toString(UA.getDadosDoCandidato().getPontuacaoCandidato()), 52)+
                      "|"+StringUtils.center(Double.toString(UA.getDadosDoCandidato().getRendaCandidato()), 45)+"|\n";

                       UA = UA.getProximo();
                       c++;
        }
        relatorio += linha_divisora;
    }

    if(!relatorio.equals(""))
        JOptionPane.showMessageDialog(null,relatorio,tituloDasTelas,JOptionPane.PLAIN_MESSAGE);
    else
        JOptionPane.showMessageDialog(null,"Não existe(m) usuário(s) cadastrado(s)!",tituloDasTelas,JOptionPane.PLAIN_MESSAGE);

}

public boolean AlterarDadosCandidato(int _cc, String _nc, String _dnc, double _pc, double _rm) 
{
    throw new UnsupportedOperationException("Not supported yet.");
}

public boolean AlterarDadosCandidato(No Candidato) 
{
    throw new UnsupportedOperationException("Not supported yet.");
}

public static void ClassificarCandidados(EstruturaDeDados LDEClassificados) 
{

    Candidato Candidato_AUX;
    No UA = LDEClassificados.getInicioDaLista();
    No PU = LDEClassificados.getInicioDaLista().getProximo();

    int length = LDEClassificados.getQuantidadeCandidatos();

    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - (i+1); j++) {
            if (UA.getDadosDoCandidato().getPontuacaoCandidato() > PU.getDadosDoCandidato().getPontuacaoCandidato()) {

                Candidato_AUX = UA.getDadosDoCandidato();
                UA.setDadosDoCandidato(PU.getDadosDoCandidato());
                PU.setDadosDoCandidato(Candidato_AUX);
            }
             UA = UA.getProximo();
             PU = PU.getProximo();
        }
        UA = LDEClassificados.getInicioDaLista();
        PU = LDEClassificados.getInicioDaLista().getProximo();
    }
    EstruturaDeDados.MostrarCandidatos(LDEClassificados, "Relatório Por Ordem de Pontuação");

}

public void ListarClassificados() 
{
    throw new UnsupportedOperationException("Not supported yet.");
}

public void ListarSuplentes() 
{
    throw new UnsupportedOperationException("Not supported yet.");
}

}

Ramon, put the class Structured too. It will help in the answer.

– André Lins

2019/04/21 at 13:51
She’s a little big, but I put.

– Ramon Almeida

2019/04/21 at 14:26

1 answer

Browser other questions tagged java chain-list

You are not signed in. Login or sign up in order to post.

by Ramon Almeida • **382** points · Answer 1 · 2019-04-21T21:01:30+00:00

To solve this problem, I followed the following steps:

Create a Data Type Arraylist which in this case is Candidate.

ArrayList<Candidato> copiaLDE = new ArrayList();

EstruturaDeDados LDEClassificados = new EstruturaDeDados();

Once this is done, in a repeat loop, add all candidates in Arraylist.

while (UA != null) {            
    copiaLDE.add(UA.getDadosDoCandidato());
    UA = UA.getProximo();
}

Now just use the method itself "Insert.

for (int i = 0; i < length; i++) {
    LDEClassificados.InserirCandidato(i, copiaLDE.get(i));
}