Ir ao conteúdo
  • Cadastre-se
Luca Neto

Ordem crescente/decrescente dados de lista duplamente encadeada

Recommended Posts

Olá, boa tarde.

Estou fazendo um programa em pascal que tem como objetivo armazenar placas de carro em lista duplamente encadeadas. Neste programa é preciso que se faça a gravação,exclusão de itens, que se liste eles e que se possa busca-los ou pelas letras ou pelos números. Precisa também que se mostre os dados inseridos na lista ordenados em ordem crescente, e também mostrar apenas os 2 primeiros números das placas ordenados de forma crescente e de.crescente.Não sou muito bom em programação e acabei empacando nessa parte e não consigo entender como fazer essa ordenação. Vou postar o código do que fiz até agora pra que fique mais fácil de compreender o que estou fazendo.

Código:
 

Spoiler

program Lista_Duplamente_Encadeada;

uses crt;

type
bloco = ^no;
placas = record
  letras:String[3];//tentei delimitar a quantia de caracteres mas não parece ter dado muito certo a ideia ;(
  numeros:String[4];
end;

no = record
  info:placas;
  dir,esq:bloco;
end;

var
inicio,fim,aux:bloco;
option: integer;
letras,numeros:string;

//procedure de criação
procedure criar;
begin
  inicio := nil;
  fim := nil;
end;

//função de verificação
function verificar : boolean;
begin
  verificar := ( inicio = nil );
end;

//procedure responsável pela pesquisa por letras

function pesquisarPorLetras(nome:string):placas;

var
numero:integer;

begin
  aux := inicio;
  numero := 0;
  gotoxy(8,18);
  writeln;
  while ( aux <> nil ) do
  begin
    if ( aux^.info.letras = nome ) then
    begin
      writeln('       =====================================================');
      
      writeln('        LETRAS : ' , aux^.info.letras);
      
      writeln('        NÚMEROS : ', aux^.info.numeros);
      
      writeln('       =====================================================');
      numero := numero +1;
      pesquisarPorLetras := aux^.info;
    end;
    
    aux := aux^.dir;
  end;
  if ( numero = 0 ) then
  begin
    writeln('       Nenhuma placa cadastrada com estas letras');
  end;
end;

//procedure responsável pela pesquisa por números

procedure pesquisarPorNumeros(numeros:string);

var
numero:integer;

begin
  aux := inicio;
  numero := 0;
  
  gotoxy(8,18);
  writeln;
  
  while ( aux <> nil ) do
  begin
    if ( aux^.info.numeros = numeros ) then
    begin
      writeln('      ======================================================');
      
      writeln('       LETRAS : ' , aux^.info.letras);
      
      writeln('       NUMEROS : ', aux^.info.numeros);
      
      writeln('      ======================================================');
      numero := numero+1;
    end;
    
    aux := aux^.dir;
  end;
  if ( numero = 0 ) then
  begin
    writeln('       Nenhuma placa cadastrada com estes números ');
  end;
end;

//procedure para cadastrar placas no sistema

procedure cadastrar;

var
cad : placas;
c:integer; //vou atribuir códigos a cada registro inserido pra visualizar melhor na manipulação
begin
  
  c := 0001;
  gotoxy(3,14);textcolor(red+blink);
  writeln('                     CADASTRAR                       ' );
  
  textcolor(7);
  textbackground(2);
  gotoxy(3,15);
  writeln(' ===================================================');
  
  gotoxy(3,16);
  writeln('| Código do registro : ',c,'                                        |');
  
  gotoxy(3,18);
  writeln('| Letras:                                   |' );
  
  gotoxy(3,20);
  writeln('| Números:                                          |');
  
  gotoxy(3,23);
  writeln(' ===================================================');
  
  gotoxy(21,18);readln(cad.letras);
  gotoxy(14,20);readln(cad.numeros);
  
  new(aux);
  aux^.info := cad ;
  if ( verificar = true ) then
  begin
    aux^.dir := nil;
    aux^.esq := nil;
    inicio := aux;
    fim := aux;
  end
  else
  begin
    aux^.esq := nil;
    aux^.dir := inicio;
    inicio^.esq := aux;
    inicio := aux;
  end;
  gotoxy(3,24);writeln(' Cadastro foi efetuado com sucesso!!!! ');
  readkey;
  
end;

//procedure para exclusão das placas

procedure excluirPlaca( nome : string );
begin
  aux^.info := pesquisarPorLetras(nome);
  
  if ( aux = nil ) then
  begin
    gotoxy(3,20);textcolor(red);
    writeln('Não existe placa cadastrada !!! ');
    textcolor(2);
  end
  else
  begin
    if (aux = inicio) then
    begin
      inicio := inicio^.dir;
      aux^.dir := nil;
      inicio^.esq := nil;
      dispose(aux);//dispose é pra limpar memória,é pra fazer isso ao menos
    end
    else
    begin
      if ( aux = fim  ) then
      begin
        fim := fim^.esq;
        fim^.dir := nil;
        aux^.esq := nil;
        dispose(aux); //dispose é pra limpar memória,é pra fazer isso ao menos
      end
      else
      begin
        aux^.esq^.dir := aux^.dir ;
        aux^.dir^.esq := aux^.esq ;
        aux^.dir := nil;
        aux^.esq := nil;
        dispose(aux);
      end;
    end;
  end;
end;

//procedure que faz a listagem das placas

procedure listarPlacas;

begin
  clrscr;
  textcolor(7);
  gotoxy(10,1);
  writeln('##########################################');
  
  gotoxy(10,3);
  textcolor(red+blink);
  writeln('#      Lista de placas cadastradas no sistema       #');
  textcolor(7);
  
  aux := inicio;
  gotoxy(4,5);
  writeln;
  if ( aux = nil ) then
  writeln('         Não existe nenhuma placa cadastrada' );
  
  while aux <> nil do
  
  begin
    writeln('         ==========================================');
    
    writeln('         LETRAS : ' , aux^.info.letras);
    
    writeln('         NÚMEROS : ', aux^.info.numeros);
    
    writeln('         ==========================================');
    aux := aux^.dir;
  end;
  readkey;
  
end;

//listas os numeros das placas em ordem crescente

procedure listarNumerosPlacasCrescente;
begin
  clrscr;
  textcolor(7);
  gotoxy(10,1);
  writeln('##########################################');
  
  gotoxy(10,3);
  textcolor(red+blink);
  writeln('#      Lista de placas cadastradas no sistema       #');
  textcolor(7);
  
  aux := inicio;
  gotoxy(4,5);
  writeln;
  if ( aux = nil ) then
  writeln('         Não existe nenhuma placa cadastrada' );
  
  while aux <> nil do
  begin
    writeln('         ==========================================');
    
    writeln('         NÚMEROS : ', aux^.info.numeros);
    
    writeln('         ==========================================');
    aux := aux^.dir;
  end;
  readkey;
  
end;

//listas os numeros das placas em ordem decrescente

procedure listarNumerosPlacasDecrescente;
begin
  clrscr;
  textcolor(7);
  gotoxy(10,1);
  writeln('##########################################');
  
  gotoxy(10,3);
  textcolor(red+blink);
  writeln('#      Lista de placas cadastradas no sistema       #');
  textcolor(7);
  
  aux := inicio;
  gotoxy(4,5);
  writeln;
  if ( aux = nil ) then
  writeln('         Não existe nenhuma placa cadastrada' );
  
  while aux <> nil do
  begin
    writeln('         ==========================================');
    
    writeln('         NÚMEROS : ', aux^.info.numeros);
    
    writeln('         ==========================================');
    aux := aux^.dir;
  end;
  readkey;
  
end;

//menu principal do sistema com todas as opções e enfeites gráficos pra ficar mais legal :)
begin
  clrscr;
  textbackground(2);
  criar;
  //enquanto não for 'x' opções eles vai executar e tal
  while( option <> 7 ) do
  begin
    clrscr;
    textcolor(7);
    writeln('  ===========================================================================');
    gotoxy(3,2);textcolor(red+blink);
    writeln('+                CADASTRO DE PLACAS DE CARRO          +');   //esse bloco aqui é
    textcolor(7);                                                                                //tudo mero enfeite inútil pra
    writeln('  ============================================================================');  //ficar fresco mesmo
    writeln;
    writeln;
    writeln;
    writeln('                  SELECIONE UMA DAS OPÇÕES ABAIXO                 ');
    writeln;
    writeln('  [1] Cadastrar placas ' );
    writeln('  [2] Pesquisar placas ' );
    writeln('  [3] Excluir placas ' );                      //esse aqui é o que aparece lá na tela
    writeln('  [4] Listar placas em ordem crescente ' );
    writeln('  [5] Listar números das placas em ordem crescente ' );
    writeln('  [6] Listar números placas em ordem decrescente ' );
    writeln('  [7] Finalizar sistema ' );
    
    gotoxy (35,8);
    textcolor(red);
    textbackground(white);
    
    gotoxy (35,9);
    writeln('==============');
    
    gotoxy (35,10);
    writeln('| OPCAO =    |' );   //aqui é o quadradinho
    //onde fica pra digitar opção,também apenas enfeite
    gotoxy (35,11);
    writeln('==============');
    
    gotoxy (45,10);
    readln(option);
    textcolor(7);
    textbackground(2);
    
    case (option) of
      //opção que fará o cadastro das placas
      1: begin
        cadastrar; //só pra lembrar que isso aqui chama a procedure cadastrar
      end;
      //menu que permite fazer consultas de placas no sistema,coloquei a oção de consultar por letras ou números
      //para que fique mais preciso em relação as placas repetidas dentro das repetições fora da lista duplamamente encadeada
      //principal
      2: begin
        textbackground(2);
        clrscr;
        textcolor(7);
        gotoxy(8,1);
        writeln('########################################################');
        
        gotoxy(8,3);
        textcolor(red+blink);
        writeln('#                   PESQUISA DE PLACAS                   #');
        
        textcolor(7);
        writeln;
        //opções de pesquisa por letra e por números para escolha
        gotoxy(8,5);
        writeln('[1] Pesquisar por letras '); //por letras
        
        gotoxy(8,6);
        writeln('[2] Pesquisar por numeros');//por números
        
        
        gotoxy(8,8);
        writeln('[3] Voltar para o menu principal'); //retorna ro menu principal
        
        gotoxy(8,10);
        textcolor(red+blink);
        writeln(' Selecione como prefere fazer a pesquisa :                         ' );
        gotoxy(40,10);readln(option);
        textcolor(7);
        
        case (option) of
          //sub menu que chama a consula por letras da placa
          1:  begin
            gotoxy(8,13);writeln('=====================================================');
            gotoxy(8,15);writeln('| Digite as letras da placa:                          |');
            gotoxy(8,17);writeln('=====================================================');
            gotoxy(35,15);readln(letras);
            pesquisarPorLetras(letras);
          end;
          //sub menu que chama a consulta por número de placa
          2:  begin
            gotoxy(8,13);writeln('=====================================================');
            gotoxy(8,15);writeln('| Digite os números da placa:                        |');
            gotoxy(8,17);writeln('=====================================================');
            gotoxy(38,15);readln(numeros);
            pesquisarPorNumeros(numeros);
          end;
          //para eclusão de placas do sistema
          3:  begin
            excluirPlaca;
            textbackground(2);
            clrscr;
          end;
          else
        end;
        readkey;
      end;
      //opção que lista todas as placas
      4: begin
        textbackground(2);
        listarPlacas;
        option := 4;
      end;
      //lista os números das placas em ordem crescente
      5: begin
        textbackground(2);
        listarNumerosPlacasCrescente;
        option := 5;
      end;
      //lista os números das placas em ordem decrescene
      6: begin
        textbackground(2);
        listarNumerosPlacasDecrescente;
        option := 6;
      end;
      //opção de finalização do sistema
      7: begin
        gotoxy(3,20);
        writeln('Pressiona qualquer tecla para finalizar o sistema...');
        option := 7;
      end
      //para a mensagem de opção errada caso digitar uma opção inválida no menu
      else
      gotoxy(3,15);
      textcolor(7);
      textbackground(2);
      writeln('Opção inválida,tente novamente ' );
      readkey;
    end;
  end;
  readkey;
  
end.
//fim do programa

 

Editado por Simon Viegas
Inserir tag CODE e ajustar SPOILER

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá @Luca Neto.

 

1)

Em relação à ordenação, você pode usar um dos métodos de ordenação já existentes... claro que existe a possibilidade de você inventar um ou deduzir por conta própria algum, mas não aconselho, pelo menos por enquanto! (a roda já está inventada). Então, dos métodos existes, entre os mais práticos e simples, sugiro utilizar o Select Sort ou Bubble Sort. São intuitivos e de fácil implementação. Ai você também precisa ver se vai ordenar a lista original ou se vai fazer uma cópia (e ordenar a cópia).

 

O algoritmo para esse método também está pronto e disponível na internet, apenas você terá que adaptar para "ponteiros", já que normalmente encontram-se com "vetores". Mas o princípio é o mesmo, em vez de "percorrer posição por posição do vetor", você terá que "percorrer posições da estrutura encadeada".

 

Uma outra forma seria você utilizar uma outra estrutura de lista encadeada, onde está já insere os dados em ordem (algo como "Lista Encadeada Ordenada" (ou Lista Duplamente Encadeada Ordenada) - a sua é apenas "Lista Duplamente Encadeada"), ou seja, você adiciona todos os elementos da sua lista nessa "lista ordenada", e por consequência terá a lista ordenada.

 

Obs.: Como é fácil deduzir, para cada ordenação, você precisa definir qual o parâmetro, no caso pelas letras, ou pelos números.

 

***

 

2)

20 horas atrás, Luca Neto disse:

placas = record

  letras:String[3];//tentei delimitar a quantia de caracteres mas não parece ter dado muito certo a ideia ;(

  numeros:String[4];

end;

O que ocorre? Se for em relação aos caracteres armazenados, creio que está certo.. mesmo se digitar mais, ele só vai aceitar os 3 ou os 4 primeiros respectivamente. Se estiver se referindo na hora de digitar é assim mesmo, o Pascal não vai limitar a quantidade de caracteres digitados... esse limite é relacionado ao que vai ser armazenado.

 

Ou se for outra coisa, por favor, tente explicar melhor.

 

Obs.: Se tiver interesse para limitar na hora de digitar, ou seja, que só aceite 3 ou 4 letras e pare de escrever na tela, dá para implementar. Inclusive que só aceite letras ('A' a 'Z', no caso). Eu até tenho uma ideia de como pode fazer... mas você pode deixar isso para depois, já que não posso te dar uma resposta pronta para isso, e creio que não vai ser tão simples tentar explicar como fazer agora. (não seria nada de outro mundo, entretanto acho que isso seria tema para um tópico exclusivamente para isso).

 

***

 

No aguardo.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×