Ir ao conteúdo
  • Cadastre-se

Lucas LC

Membro Pleno
  • Posts

    48
  • Cadastrado em

  • Última visita

posts postados por Lucas LC

  1. Eu também sempre tive a impressão que estava aprendendo errado e os profissionais sempre vão usar códigos mais enxutos, porque levam menos tempo. Meu professor da faculdade sempre pega no pé a questão da "lógica de programação", saber as tarefas que o algoritmo vai fazer sem compilar, parece até sinistro, mas faz bastante sentido e quem é novato precisa passar por esse processo.

     

    Por exemplo: 

     

    Em 26/07/2020 às 22:08, sandrofabres disse:

    ClasseCoisa objeto = new ClasseCoisa(); objeto.exists();

    É bem mais fácil de enxergar que está declarando uma classe e está instanciando tudo na mesma linha. 

     

    Em 26/07/2020 às 22:08, sandrofabres disse:

    (coisaBoolean ? 10000 :  0)

    Não é tão simples de entender, mas tem sua elegância. Porém, tornar seu código o mais legível possível pode fazer muita diferença para alguém que precisa mantê-lo no futuro.

    • Curtir 1
  2. Em 23/09/2020 às 17:52, arfneto disse:

    Que está lá na versão que eu escrevi. Pode usar algo assim. tem a lista dos slots ocupados na fila, o total deles, o ponteiro para o sentinela e todos os ponteiros para os registros na listagem por prioridade, que é a fila propriamente dita

    Perfeito arfneto, agradeço sua ajuda. 

  3. 4 horas atrás, arfneto disse:

    A saída de exibirLog() está um pouco ruim de ler, para uma rotina que serve justamente para certificar que a estrutura está ok e os ponteiros estão certinhos. Talvez deva rever.

    Farei isso, obrigado. 

  4. Concluído!!!

    #include "filaDePrioridade.h"
    
    PFILA criarFila(int max){
      PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE));
      res->maxElementos = max;
      res->arranjo = (PONT*) malloc(sizeof(PONT)*max);
      int i;
      for (i=0;i<max;i++) res->arranjo[i] = NULL;
      PONT cabeca = (PONT) malloc(sizeof(ELEMENTO));
      res->fila = cabeca;
      cabeca->ant = cabeca;
      cabeca->prox = cabeca;
      cabeca->id = -1;
      cabeca->prioridade = 1000000;
      return res;
    }
    
    void exibirLog(PFILA f){
      printf("Log [elementos: %i (alem do no cabeca)]\n", tamanho(f));
      PONT atual = f->fila;
      printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
      atual = atual->prox;
      while (atual != f->fila){
      printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
      atual = atual->prox;
      }
      printf("\nElementos validos: ");
      atual = atual->prox;
      while (atual != f->fila){
        printf("[%i;%f;%p] ", atual->id, atual->prioridade, atual);
        atual = atual->prox;
      }
    
      printf("\nValores do arrajo:\n\[ ");
      int x;
      for (x=0;x<f->maxElementos;x++) printf("%p ",f->arranjo[x]);
      printf("]\n\n");
    }
    
    
    int tamanho(PFILA f){
    int tam = 0; 
    PONT atual = f->fila->prox; 
    
    while(atual != f->fila) {
    tam++; 
    atual = atual->prox;
     
    }
    return tam; 
    }
    
    
    ELEMENTO* buscaSeqExc(PFILA f, float prioridade,PONT* atual, PONT* ant) {
    *ant = f->fila;
    *atual = (*ant)->prox;
    
    while((*atual)->prioridade > prioridade && (*atual) != f->fila) {
    *ant = *atual;
    *atual =(*atual)->prox;
    
    }
    }
    
    bool trocar(PFILA f, int id, float prioridade){
     
    (f->arranjo[id]->ant)->prox = f->arranjo[id]->prox;
    (f->arranjo[id]->prox)->ant = f->arranjo[id]->ant;
    
    ELEMENTO* novo = f->fila->prox; 
    while (novo != f->fila){
    if (prioridade >= novo->prioridade) break;
        novo = novo->prox;
        } 
    novo->ant->prox = f->arranjo[id];
    f->arranjo[id]->ant = novo->ant;
    novo->ant = f->arranjo[id];
    f->arranjo[id]->prox = novo;
    f->arranjo[id]->prioridade = prioridade;
    
       return true;
    }
    
    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT ant, atual;
      ELEMENTO* novoElemento;
      PONT* arranjo;
       
     novoElemento=buscaSeqExc(f,prioridade,&atual,&ant);
     if(f->arranjo[id] != NULL) return false;
     
     if(id < 0 || id >= f->maxElementos) return false;
     
     novoElemento = (PONT) malloc(sizeof(ELEMENTO));
    
     f->arranjo[id] = novoElemento;
    
     novoElemento->ant = ant;
     novoElemento->prox = ant->prox;
     ant->prox = novoElemento;
     novoElemento->prox->ant = novoElemento;
     novoElemento->prioridade = prioridade;
     novoElemento->id = id;
    
      resposta = true;
      return resposta;
    }
    
    bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
     
     if (f == NULL)  return false; 
     if (id < 0)     return false; 
     if (id >= (f->maxElementos)) return false; 
     if ((f->arranjo[id] == NULL) || (f->arranjo[id]->ant == NULL))
       return false;
    
     
     if ((f->arranjo[id] == NULL) || (f->arranjo[id]->ant == NULL)) return false;
    
     if (f->arranjo[id]->prioridade  >= novaPrioridade) return false;
     
      
       trocar(f, id, novaPrioridade);
     
      resposta = true;
      return resposta;
    }
    
    bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
    
       if (f == NULL) return false; 
       if (id < 0) return false; 
       if (id >= (f->maxElementos)) return false;
       if ((f->arranjo[id] == NULL) || (f->arranjo[id]->ant == NULL))
       return false;
    
        
       if ((f->arranjo[id] == NULL) || (f->arranjo[id]->ant == NULL)) return false;
    
       if (f->arranjo[id]->prioridade <= novaPrioridade) return false;
    
       
       trocar(f, id, novaPrioridade);
    
     
      resposta = true;
    
      return resposta;
    }
    
    PONT removerElemento(PFILA f){
      PONT resposta = NULL;
      PONT ant;
      PONT* arranjo;
      int id;
     
      if (f->fila->prox == f->fila) return resposta;
       
    ELEMENTO* apagar = f->fila->prox;
        int idApagar = apagar->id;
        
        f->fila->prox = apagar->prox;
        apagar->prox->ant = f->fila;
        f->arranjo[idApagar] = NULL;
     
    resposta = apagar;
        return resposta;
    }
     
    bool consultarPrioridade(PFILA f, int id, float* resposta){
      bool resp = false;
    
      if (f == NULL) return false; 
      if (id < 0) return false; 
      if (id >= (f->maxElementos)) return false; 
      if ((f->arranjo[id] == NULL) || (f->arranjo[id]->ant == NULL)) return false;
    
      *resposta = f->arranjo[id]->prioridade;
     
      resp = true;
      return resp;
    }

     

    • Curtir 1
  5. 6 horas atrás, arfneto disse:

    Leu o código que escrevi?

    Olhei sim 

    adicionado 1 minuto depois
    6 horas atrás, arfneto disse:

    O editor de código não voltou ainda ao menos para mim. Quando voltar poste seu código.

    Estou fazendo alguns ajustes, quando eu terminar eu posto aqui. 

  6. 8 horas atrás, arfneto disse:

    Você leu o código nos links que eu te mandei? entendeu? baixou os programas?

     

    Foi mal acabei não vendo, mas vou dar uma olhada. 

    adicionado 44 minutos depois
    9 horas atrás, arfneto disse:

    Você leu o código nos links que eu te mandei? entendeu? baixou os programas?

     

    Entendi o erro do meu código, eu achava que estava incluindo em uma lista circular, mas confundi as interpretações e fiz uma inserção de uma fila normal, ontem a noite eu corrigi essa parte, mas tinha um sinal errado que cancelava toda a minha inclusão. Com seu código consegui perceber isso. 

     

    • A função de busca estava ordenando corretamente, mas parecia que não era muito preciso comparar prioridade seria melhor comparar endereço do elemento. 
    • A função de troca eu tentei implementar no inicio, mas como estava dando erro, acabei deixando de lado. 
    adicionado 50 minutos depois
    9 horas atrás, arfneto disse:

    Você leu o código nos links que eu te mandei? entendeu? baixou os programas?

     

    Obrigado pela ajuda, agora está correto e consegui entender o processo. 

     

    No começo pareceu confuso, mas aos poucos fui entendendo o ponto chave desse programa, mesmo eu sendo teimoso querendo implementar um código complexo rs, mas o senhor ajudou muito. 

     

    Continue assim ajudando as pessoas. 

  7. 25 minutos atrás, arfneto disse:

    O sw do forum está com problemas, como deve ter visto nesses dias. Hoje não tenho a opção de publicar código... :) por exemplo. Algumas funções sumiram do editor. Não vou copiar o código aqui porque não compensa o trabalho. Depois talvez, se voltar  o editor.

    Sem problemas, deixei o mais simples possível, acabei com as condições, mas não está inserindo nada 😰

     

     

    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT ant, atual
      ELEMENTO* novoElemento;
      PONT* arranjo;
      PONT prox = ant->prox;
       
     novoElemento = buscaSeqExc(f,prioridade,&atual,&ant);
      
     if(id < 0 || id >= f->maxElementos) return false;
     
     if(f->arranjo[id] == NULL) return false;
     
     novoElemento = (PONT) malloc(sizeof(ELEMENTO));

     f->arranjo[id] = novoElemento;

     

     novoElemento->ant = ant;
     novoElemento->prox = ant->prox;
     ant->prox = novoElemento;
     novoElemento->prox->ant = novoElemento;
     novoElemento->prioridade = prioridade;
     novoElemento->id = id;

      resposta = true;
      return resposta;
    }

  8. 32 minutos atrás, arfneto disse:

    Fazendo assim conserta o problema de tamanho() já que o modelo não tem o óbvio campo. Não tem cabimento percorrer toda a lista a cada vez que consulta o tamanho, e assim

    Posso dar uma olhada no código todo ? pra mim ver essas mudanças

  9. 17 horas atrás, arfneto disse:

    Não é exatamente que está pedindo, mas se leu o que escrevi já sabe que se gravar NULL naquele vetor ao remover alguém o endereço vazou. Jamais vai por as mãos nele de novo. E não vai poder liberar. Trata-se de um simples erro. Se não pode liberar tem que usar em insere(). Não pode alocar um registro de novo para o mesmo 

    Ata beleza.

    adicionado 7 minutos depois

    Arrumei os ponteiros, fiz 3 condições para inclusão o primeiro é quando a lista está vazia só tem o cabeça, segundo incluir no inicio quando minha prioridade que foi passado como parâmetro for maior que todos na fila e terceiro incluir no final da fila se for menor. 

     

    Só tem um erro quando ele vai imprimir ele coloca em ordem que foi adicionado, será que preciso adicionar um código de ordenação ? 

    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT novoElemento, ant, atual;
      PONT* arranjo;
      PONT prox = ant->prox;
      PONT* aux;
    
      novoElemento = buscaSeqExc(f,prioridade,&atual,&ant);
    
     if(id < 0 || id >= f->maxElementos) return false;
     
     if(id == f->fila->id) return false;  
    
    
     novoElemento = (PONT) malloc(sizeof(ELEMENTO));
     f->arranjo[id] = novoElemento;
     
     if(f->fila == f->fila->prox) { 
      novoElemento->prox = ant->prox;
      ant->prox = novoElemento;
      novoElemento->prioridade = prioridade; 
      novoElemento->id = id; 
     }
     
     if(prioridade > f->fila->prioridade) {
     novoElemento->ant = f->fila; 
     novoElemento->prox = f->fila->prox; 
     f->fila->prox = novoElemento; 
     novoElemento->prox->ant = novoElemento; 
     novoElemento->prioridade = prioridade; 
     novoElemento->id = id; 
     }
    
     if(prioridade < f->fila->prioridade){
     novoElemento->prox = f->fila;
     novoElemento->ant = f->fila->ant;
     f->fila->ant = novoElemento;
     novoElemento->ant->prox = novoElemento;
     novoElemento->prioridade = prioridade; 
     novoElemento->id = id; 
     }
     
          
      resposta = true;
      return resposta;
    }

     

  10. 1 hora atrás, arfneto disse:

     esse modelo é muito ruim. :( tosco. 

    Claro que não tá me ajudando muito. 

     

    O programa tá andando, eu só preciso acertar alguns ponteiros chatinhos que tá dificultando a inserção da prioridade, mudei a função de busca, porque a fila tava ordenada pela prioridade e não pelo id e também eu pensei em reaproveitar os elementos excluídos, mas não estava pedindo então deixei pra lá. 

     

    image.png.321974bab69b24471e76f94d254c32f2.png

  11. 8 horas atrás, arfneto disse:

    Esse registro é chamado sentinela --- sentinel record --- e é intocável. Existe o sentinela e de 0 a MAX registros. Não se misturam. É um jeito de implementar um buffer circular. O outro é usar um ponteiro para o início.

     

    Muitas vezes não se usa isso porque o sentinela ocupa o espaço de um registro comum, ELEMENTO no seu caso. E se imagina que usa isso porque os registros são caros e importantes, como em buffers em áudio por exemplo: se tem um buffer de 300 o que chegar sempre entra. E se não tiver lugar vai apagar algum antigo que não reproduziu ainda e vai ter uma perda. E se espera que não dê pra notar na reprodução. Então se são poucos ter um sentinela pode ser um desperdício grande. Se usar MAX 19 no seu caso vai usar 20 e perder 1 para o sentinela, 5% de perda.

    Entendi, então por ser intocável não posso incluir ele nos meus códigos. 

    adicionado 12 minutos depois
    8 horas atrás, arfneto disse:

    O outro é usar um ponteiro para o início.

    Então, para meu próximo elemento, ele precisa do endereço do meu nó cabeça para minha lista ficar ligada certo ?  Logo se o f->cabeca é intocável, usando outro ponteiro tipo f->cabeca->prox eu posso dizer que os elementos válidos começa com f->cabeca->prox.

     

    f->cabeca->prox = f->cabeca;

     

    Ai eu passo o endereço do nó cabeça para o próximo e posso usar o f->cabeca->prox como inicio em vez do f->fila.

  12. 6 minutos atrás, arfneto disse:

    A lista é pré-formatada e o id é a identificação da célula no buffer, como se fosse uma sala de espera com poltronas numeradas. Isso ajuda a entender o porque do tal arranjo, que em inglês seria array :). E lembra que em C++ por exemplo o container padrão para uma porque fila de prioridade é um vetor, que é um array chique em C++. E em C um vetor seria o normal, com a lista em torno dos índices, que são os id. E a performance seria ignorante já que as células seriam pré-alocadas e os ponteiros não seriam para a memória e sim para os índices. Já escrevi algo assim para buffers de transmissão tempos atrás.

    Exatamente uma sala de espera que é minha fila e o arranjo para guardar o endereço de cada elemento da fila e o nó cabeça como primeiro elemento, mas não sei como usar esse nó cabeça, porque sempre q uso da uns erros, 

     

    1 hora atrás, Lucas LC disse:

    PONT atual = f->fila; //Recebe o endereço do primeiro registro e guarde no atual.

    exemplo aqui, o primeiro endereço da minha fila é o nó cabeça, então seria f->fila->cabeca e adiciono elementos depois dele, mas da erro e substitui pela f->fila q é o inicio. 

     

  13. 1 hora atrás, arfneto disse:

    Poste o enunciado completo

    image.png.99b7c086d0b669c5f5f5cf897adaee75.png

     

    image.png.45c3d90a87d68d0c33334899cd163cb4.png

     

    image.png.d19b782085eee729642770a6f4d0464f.png

    adicionado 1 minuto depois
    1 hora atrás, arfneto disse:

    que devolve o elemento anterior ao que entraria com essa prioridade. Há um conceito chamado estabilidade, não sei se o enunciado fala nisso: em tendo vários elementos com a mesma prioridade eles devem estar por ordem de criação na fila. Então essa função te daria o lugar onde vai entrar o cara novo na fila: depois do endereço que ela retornar

     

    Para apagar alguém ou mudar de lugar em geral tem que olhar 3 nós para a origem e 3 para o destino. E tratar os casos limite de operar no início e no fim da lista

    De acordo com o enunciado não precisa se preocupar com elementos com a mesma prioridade. 

    adicionado 2 minutos depois
    1 hora atrás, arfneto disse:

    Faz sentido. Mas acho que arranjo é desnecessário. Pode tratar apenas início e uma função tipo

    Sem usar o arranjo como faço para colocar NULL na posição que eu tirei ? 

    adicionado 5 minutos depois
    1 hora atrás, arfneto disse:

    Entendo que não pode mudar. O que eu te disse é ainda assim pode usar a estrutura de um modo mais sadio. Por isso falei em encapsulamento.

    OK.

    adicionado 42 minutos depois
    #include "filaDePrioridade.h"
    
    PFILA criarFila(int max){
      PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE));
      res->maxElementos = max;
      res->arranjo = (PONT*) malloc(sizeof(PONT)*max);
      int i;
      for (i=0;i<max;i++) res->arranjo[i] = NULL;
      PONT cabeca = (PONT) malloc(sizeof(ELEMENTO));
      res->fila = cabeca;
      cabeca->ant = cabeca;
      cabeca->prox = cabeca;
      cabeca->id = -1;
      cabeca->prioridade = 1000000;
      return res;
    }
    
    void exibirLog(PFILA f){
      printf("Log [elementos: %i (alem do no cabeca)]\n", tamanho(f));
      PONT atual = f->fila;
      printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
      atual = atual->prox;
      while (atual != f->fila){
        printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
        atual = atual->prox;
      }
      printf("\nElementos validos: ");
      atual = atual->prox;
      while (atual != f->fila){
        printf("[%i;%f;%p] ", atual->id, atual->prioridade, atual);
        atual = atual->prox;
      }
    
      printf("\nValores do arrajo:\n\[ ");
      int x;
      for (x=0;x<f->maxElementos;x++) printf("%p ",f->arranjo[x]);
      printf("]\n\n");
    }
    
    //maxElemento é a quantidade máxima que a fila pode ter;
    //fila é os elementos que possui uma prioridade para ser inserido no arranjo(endereço);
    //arranjo armazena os endereços dos elementos;
    //PFILA f é a fila de Prioridade;
    //f->fila é o inicio da fila;
    //cabeça é o primeiro elemento da fila, com id -1 e prioridade 1000000.
    
    
    int tamanho(PFILA f){
    int tam = 0; //Guarda o número de elemento.
    PONT atual = f->fila; //Recebe o endereço do primeiro registro e guarde no atual.
    
    while(atual != NULL) {//A cada elemento válido guarde na variável tam.
    tam++; //Some mais 1.
    atual = atual->prox;// Recebe o prox elemento da fila.
     
    }
    return tam; //Quando terminar o laço com o total de elementos, retorne tam com o total.
    }
    
    //Função de Busca.
    PONT buscaSeqExc(PFILA f, int id, PONT* ant) {
    *ant = f->fila;
    PONT atual = f->fila->prox;//Primeiro elemento válido.
    
    while(atual->id < id) {
    *ant = atual;
    atual =atual->prox;
    }
    if(atual != f->fila && atual->id == id) return atual;//Encontrou
    return NULL;//Não encontrou.
    }
    
    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT novoElemento, ant;
      PONT* arranjo;
     
      novoElemento = buscaSeqExc(f,id,&ant);
      /*Se o identificador for menor que 0 ou maior
      max de elementos na fila retorne false */
     if(id < 0 || id >= f->maxElementos) return false;
     //Caso já tenha esse id na fila.
     if(id == f->fila->id) return false;  
     
     //Caso contrário aloque memória para esse novo elemento que irá inserir.
     novoElemento = (PONT) malloc(sizeof(ELEMENTO));
     arranjo = &novoElemento;//Colocando o endereço no arranjo.
     
     //Acertar os ponteiros com o novoElemento usando a prioridade.
     if(novoElemento->prioridade > f->fila->prioridade) {
     novoElemento->prox = f->fila;//O próximo do novoElemento será o primeiro registro da fila.
     f->fila = novoElemento;//Se torna o novo inicio da lista.
     }
     else {
      novoElemento->prox = ant->prox;
      ant->prox = novoElemento;
     
      resposta = true;
      return resposta;
    }
    }
    
    
    bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
     
     
      if(id < 0 || id >= f->maxElementos) return false;
     
      if(id == f->fila->id) return false;  
    
      if(f->fila->prioridade >= novaPrioridade) return false;
     
      else //Trocar a prioridade.
          for (id=0;id<f->maxElementos;id++) {
     f->arranjo[id]->prioridade = novaPrioridade;
          }
      resposta = true;
    
      return resposta;
    }
    
    
    bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
    
      if(id < 0 || id >= f->maxElementos) return false;
    
      if(id != f->fila->id) return false;  
    
      if(f->fila->prioridade <= novaPrioridade) return false;
      //Trocar sua prioridade, caso a novaPrioridade seja maior que a prioridade na fila.
      else //Trocar a prioridade.
          for (id=0;id<f->maxElementos;id++) {
     f->arranjo[id]->prioridade = novaPrioridade;
     }
      resposta = true;
    
      return resposta;
    }
    
    //Função de Busca de id.
    ELEMENTO* buscaPorID(PFILA f, int id) {
    PONT* ant;
    *ant = f->fila;
    PONT atual = f->fila->prox;//Primeiro elemento válido.
    
    while(atual->id < id) {
    *ant = atual;
    atual =atual->prox;
    }
    if(atual != f->fila && atual->id == id) return atual;//Encontrou
    return NULL;//Não encontrou.
    }
    
    PONT removerElemento(PFILA f){
      PONT resposta = NULL;
      PONT i,ant;
      int id;
     //Devolve o endereço se ele está na fila.
      i=buscaPorID(f,id);//Busca pelo elemento.
      //Verificar se a fila possui algum ponteiro válido.
      if(i == NULL) return resposta;
     
      //Caso contrário da para excluir.
      ant->prox = i->prox;//Anterior dele apontar para o próximo.
      
      i = NULL;//Colocar NULL na posição que o elemento foi retirado.
      
      resposta = i;
      
      return resposta;
     }
    
    
    bool consultarPrioridade(PFILA f, int id, float* resposta){
      bool resp = false;
    
      //Identificador inválido.
       if(f->fila->id < 0 || f->fila->id >= f->maxElementos) return false;
     //Identificador diferente com os que tem na fila.
       if(id != f->fila->id) return false;  
       
       else
      resposta = &(f->fila->prioridade);//Colocar na memória o valor da prioridade.
     
      resp = true;
      return resp;
    }

     

    adicionado 43 minutos depois

    Os erros sumiram, só preciso verificar agora se as interações estão corretas. 

    • Obrigado 1
  14. 37 minutos atrás, arfneto disse:

    Sim. Faz total sentido

    Ufa que bom.

    adicionado 2 minutos depois

    De acordo com o enunciado não posso liberar, porque o usuário pode querer usar o elemento excluído. 

     

    image.png.ff480bd6434df6767ea363381c6b9027.png

    adicionado 3 minutos depois
    40 minutos atrás, arfneto disse:

    Fuja disso. Use o próprio conceito de encapsulamento :) e redefina o USO desse modelo absurdo que recebeu. E escreva as funções de um modo convencional.

     

    kkkk não tenho permissão de mudar. 

    adicionado 24 minutos depois
    56 minutos atrás, arfneto disse:

    Quando mais seu modelo se afasta da realidade simples de uma fila de prioridade, implementada através de uma lista ligada que não deveria estar aparecendo, usando uma prioridade que está fora do dado e não como atributo dele, declarada como float, o trabalho vai ficando mais e mais difícil a toa.

     

    Vamos esquecer o devolverNó, e se eu fosse interpretar dessa forma: 

     

    image.png.d4ee6760a8626dffedcda3326c0efe85.png

     

     

    Primeiro eu busco o elemento para excluir, o if significa  q o elemento não existe e retorno NULL, mas se existe o elemento i vai da para excluir, eu faço o anterior apontar para o próximo dele para a minha lista não ficar "quebrada" e colocar NULL na posição dele no arranjo[i] e retornar o endereço. Faz sentido com esse código ? 


     

  15.  

    arfneto consegui corrigi a minha função de busca, usei um número inteiro que é o id(identificador) em vez de um tipo float que não é o usual quando se usa operadores como == e !=, o ponteiro atual recebe o primeiro elemento válido da lista, fiz um laço enquanto o identificador apontado pelo atual for menor que o elemento buscado ele passa para o próximo elemento da fila, quando ele sair do laço vai para minha condição if para ter certeza q o elemento foi encontrado, o elemento atual tem q ser diferente do elemento que está no inicio da minha fila q é o nó cabeça e o atual ser igual ao id buscado, caso não encontre retorna NULL. Faz sentido ?

    22 horas atrás, arfneto disse:
    
       //Função de Busca. 
    PONT buscaSeqExc(PFILA f, int id, PONT* ant) { 
    *ant = f->fila;
    PONT atual = f->fila->prox;//Primeiro elemento válido.
    
    while(atual->id < id) { 
    *ant = atual;
    atual =atual->prox;
    }
    if(atual != f->fila && atual->id == id) return atual; 
    return NULL;//Não encontrou. 
    }

     

    Mas agora estou com problema nessa função excluir elemento, os métodos abaixo são remover elementos que retorna NULL se não tiver nenhum elemento válido na fila e caso contrário, retira o primeiro elemento válido da lista, coloquei o valor NULL na posição correspondente desse elemento no ponteiro arranjo e retornei o endereço do respectivo elemento.

     

    Como não posso liberar a memória do elemento eu fiz uma função devolverNó para colocar no inicio da minha fila, caso o usuário precise usar. Mas nesse método eu posso colocar ele no inicio da minha lista f ou f->fila ou só coloco NULL na posição que ele foi retirado e não libero a memória dele ? nesse método fiquei em dúvida.

     

     

    image.png.72716d5042890a5608aaa3d2eff4d383.png

     

     

    22 horas atrás, arfneto disse:
    
    //Lista de disponíveis
    void devolverNo(PFILA f, int j){
         f->arranjo[j]->prox = f->fila;//Colocar no inicio da fila.
         f->fila = j;
    } /* devolverNo */
    
    
    PONT removerElemento(PFILA f){
      PONT resposta = NULL;
      PONT* arranjo; //Armazena endereço de ponteiros.
      int elemento;
      PONT *ant;
     
      //Verificar se a fila possui algum ponteiro válido.
      if(f->fila == NULL) return resposta;
     
      //Retirar o primeiro elemento da lista.
      if(f->fila->ant == NULL)
     
      f->fila = f->arranjo[elemento]->prox;
     
      else f->arranjo[ant]->prox = f->arranjo[elemento]->prox;
     
      devolverNo(f,elemento);//Guardar na lista de disponíveis no inicio da fila.
     
      arranjo[elemento] = NULL;
     
       return elemento;
     }

     

     

    adicionado 3 minutos depois

    E consegui arrumar alguns erros básicos de ponteiros no código. 

  16. arfneto eu entendi o conceito de uma fila de prioridade, mas essa atividade que estou desenvolvendo não está relacionada apenas com fila de prioridade, a sua dedução que é lista ligada junto com fila de prioridade está correto. 

     

    Meus ponteiros atual e prox está dando erro dentro da função inserir e na função busca. 

     

    image.png.647b0e4cc1551c6bdcb9390a79584c47.png

     

     

    Um ponteiro não pode apontar para uma variável do tipo float ? será que é isso problema de semântica ? 

     

  17. Boa tarde!

     

    Alguém poderia dar uma ajuda no código abaixo, sou novo em C em relação a ponteiros e tá dando muitos erros relacionado. 

     

    OBS: não posso mudar as estruturas. 

     

    #include <stdlib.h>
    #include <stdio.h>
    #define true 1
    #define false 0
    
    typedef int bool;
    
    typedef struct aux {
      int id;
      float prioridade;
      struct aux* ant;
      struct aux* prox;
    } ELEMENTO, * PONT;
    
    typedef struct {
      int maxElementos;
      PONT fila;
      PONT* arranjo;
    } FILADEPRIORIDADE, * PFILA;
    
    PFILA criarFila(int max);
    
    int tamanho(PFILA f);
    
    bool inserirElemento(PFILA f, int id, float prioridade);
    
    bool aumentarPrioridade(PFILA f, int id, float novaPrioridade);
    
    bool reduzirPrioridade(PFILA f, int id, float novaPrioridade);
    
    PONT removerElemento(PFILA f);
    
    bool consultarPrioridade(PFILA f, int id, float* resposta);

     

     

    Fila de Prioridade 

     


     

    #include "filaDePrioridade.h"
    
    PFILA criarFila(int max){
      PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE));
      res->maxElementos = max;
      res->arranjo = (PONT*) malloc(sizeof(PONT)*max);
      int i;
      for (i=0;i<max;i++) res->arranjo[i] = NULL;
      PONT cabeca = (PONT) malloc(sizeof(ELEMENTO));
      res->fila = cabeca;
      cabeca->ant = cabeca;
      cabeca->prox = cabeca;
      cabeca->id = -1;
      cabeca->prioridade = 1000000;
      return res;
    }
    
    void exibirLog(PFILA f){
      printf("Log [elementos: %i (alem do no cabeca)]\n", tamanho(f));
      PONT atual = f->fila;
      printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
      atual = atual->prox;
      while (atual != f->fila){
        printf("%p[%i;%f;%p]%p ", atual->ant, atual->id, atual->prioridade, atual, atual->prox);
        atual = atual->prox;
      }
      printf("\nElementos validos: ");
      atual = atual->prox;
      while (atual != f->fila){
        printf("[%i;%f;%p] ", atual->id, atual->prioridade, atual);
        atual = atual->prox;
      }
    
      printf("\nValores do arrajo:\n\[ ");
      int x;
      for (x=0;x<f->maxElementos;x++) printf("%p ",f->arranjo[x]);
      printf("]\n\n");
    }
    
    //maxElemento é a quantidade máxima que a fila pode ter.
    //fila é os elementos que possui uma prioridade para ser inserido no arranjo(endereço).
    //arranjo armazena os endereços dos elementos.
    //PFILA f é a fila de Prioridade. 
    
    int tamanho(PFILA f){
    int tam = 0; //Guarda o número de elemento. 
    PONT atual = f->fila; //Recebe o endereço do primeiro registro e guarde no atual. 
    
    while(atual != NULL) {//A cada elemento válido guarde na variável tam.
    tam++; //Some mais 1. 
    atual = atual->prox;// Recebe o prox elemento da fila.
      
    }
    return tam; //Quando terminar o laço com o total de elementos, retorne tam com o total.
    }
    
    //Função de Busca. 
    void buscaSeqExc(PFILA f, float prioridade, PONT* atual, PONT* ant) { 
    *ant = f->fila;//Inicio da fila.
    *atual = ant->prox;//Próximo elemento da fila.
    
    while(atual->prioridade > prioridade && atual->prioridade != f->fila->prioridade) { 
    
    *ant = prox;
    *atual = atual->prox;
    }
    }
    
    //Função para trocar os elementos.
    void troca(float *a, float *b) { 
    
    float k = *a;//Guarda onde o a aponta em k. 
    *a = *b; //Guarda onde o b aponta na posição a. 
    *b = k;//Guarda onde o a aponta na posição b. 
    }
    
    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT *arranjo;
      PONT novoElemento, ant;
      
      novoElemento = buscaSeqExc(f,prioridade,&atual,&ant);
      /*Se o identificador for menor que 0 ou maior
      max de elementos na fila retorne false */ 
     if(id < 0 || id >= f->maxElementos) return false; 
     //Caso já tenha esse id na fila. 
     if(id == f->fila->id) return false;  
     
     //Caso contrário aloque memória para esse novo elemento que irá inserir. 
     novoElemento = (PONT) malloc(sizeof(ELEMENTO));
     novoElemento->arranjo = arranjo;//Colocando o endereço no arranjo.
     
     //Acertar os ponteiros com o novoElemento usando a prioridade.
     if(f->fila->novoElemento->prioridade > f->fila->prioridade) { 
     novoElemento->prox = f->fila;//O próximo do novoElemento será o primeiro registro da fila. 
     f->fila = novoElemento;//Se torna o novo inicio da lista.
     }
     else { 
      novoElemento->prox = ant->prox;
      ant->prox = novoElemento;
      
      resposta = true;
      return resposta;
    }
    }
    
    
    bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
      PONT *Arm; //Mesmo struct
      
      if(id < 0 || id >= f->maxElementos) return false; 
     
      if(id == f->fila->id) return false;  
    
      if(f->fila->prioridade >= novaPrioridade) return false; 
     
      else
           //Chamar a função troca para trocar as prioridades.
          troca(&(novaPrioridade), &(f->fila->prioridade));
     
      resposta = true;
         
      return resposta;
    }
    
    
    bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){
      bool resposta = false;
    
      if(id < 0 || id >= f->maxElementos) return false;
    
      if(id != f->fila->id) return false;  
    
      if(f->fila->prioridade <= novaPrioridade) return false;
      //Trocar sua prioridade, caso a novaPrioridade seja maior que a prioridade na fila. 
      else
      //Chamar a função troca para trocar as prioridades.
          troca(&(novaPrioridade), &(f->fila->prioridade));
      
      resposta = true;
         
      return resposta;
    }
    //Lista de disponíveis
    void devolverNo(PFILA f, PONT j){
         f->arranjo[j].prox = f->fila;
         f->fila = j;
    } /* devolverNo */
    
    PONT removerElemento(PFILA f){
      PONT resposta = NULL;
      PONT arranjo; //Armazena endereço de ponteiros.
      PONT elemento; 
      PONT *ant; 
      
      //Verificar se a fila possui algum ponteiro válido. 
      if(f->fila == NULL) return resposta; 
      
      //Retirar o primeiro elemento da lista.
      if(f->fila->ant == NULL) 
          
      f->fila = f->arranjo[elemento].prox; 
      
      else f->arranjo[ant].prox = f->arranjo[elemento].prox;
      
      devolverNo(f,elemento);//Guardar na lista de disponíveis. 
      
      arranjo[elemento] = NULL 
      
       return elemento; 
     }
     
    
    bool consultarPrioridade(PFILA f, int id, float* resposta){
      bool resp = false;
    
      //Identificador inválido.
       if(f->fila->id < 0 || f->fila->id >= f->maxElementos) return false; 
     //Identificador diferente com os que tem na fila. 
       if(id != f->fila->id) return false;  
       
       else 
           *resposta = &(f->fila->prioridade);//Colocar na memória o valor da prioridade.
      
      resp = true;
      return resp;
    }

     

     image.png.e0184461e90e0aa712bb81a211180a58.png

     

    image.png.7ce4583b570a6c92c187bd01e0e81526.png

  18. Olá pessoal!

     

    Estou com muitas dúvidas sobre ponteiros e estou tentando implementar uma função inserir na lista de prioridade duplamente ligada. Alguém poderia me ajudar no código abaixo. 

     

    Minhas estruturas: 

    typedef struct aux {
      int id;//Chave
      float prioridade;
      struct aux* ant;
      struct aux* prox;
    } ELEMENTO, * PONT;
    
    typedef struct {
      int maxElementos; //Armazena os dados 
      PONT fila; //Elementos que fica na fila
      PONT* arranjo; //Armazena os ponteiros
    } FILADEPRIORIDADE, * PFILA;

     

    image.png.34573c3fb187ff90d9a9c511c7001dfc.png

    bool inserirElemento(PFILA f, int id, float prioridade){
      bool resposta = false;
      PONT = novoElemento, ant, prox; 
    
     if(f->novoElemento.id < 0 || f->fila >= maxElementos) return false; 
     
     if(f->novoElemento.id == f->maxElementos->id) return false;  
     PFILA novoELEMENTO = (PONT) malloc(sizeof(ELEMENTO));
     arranjo = &novoElemento;
     
     novoElemento = f->maxElementos-1; //Começar no final do array e vai voltando para encotrar a prioridade. 
     while(novoElemento >= 0 && f->fila[novoElemento].prioridade >= prioridade) {
         f->fila[novoElemento+1] = f->fila[novoElemento];
         novoElemento--;
     }
     f->fila[novoElemento+1].id = id;
     f->fila[novoElemento+1].prioridade = prioridade;
     f->maxElementos++
     resposta = true;
     return resposta;
    }

     

    image.png

    • Amei 1

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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

×
×
  • Criar novo...

Ebook grátis: Aprenda a ler resistores e capacitores!

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!