Lucas LC

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: É bem mais fácil de enxergar que está declarando uma classe e está instanciando tudo na mesma linha. 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.

Perfeito arfneto, agradeço sua ajuda.

Farei isso, obrigado.

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; }

Olhei sim adicionado 1 minuto depois Estou fazendo alguns ajustes, quando eu terminar eu posto aqui.

Foi mal acabei não vendo, mas vou dar uma olhada. adicionado 44 minutos depois 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 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.

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; }

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

Ficou bem mais elegante.

Tá em ordem de inclusã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; }

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á.

Ajudou bastante, vou fazer algumas correções.

Entendi, então por ser intocável não posso incluir ele nos meus códigos. adicionado 12 minutos depois 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.

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, 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.

adicionado 1 minuto depois De acordo com o enunciado não precisa se preocupar com elementos com a mesma prioridade. adicionado 2 minutos depois Sem usar o arranjo como faço para colocar NULL na posição que eu tirei ? adicionado 5 minutos depois 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.

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. adicionado 3 minutos depois kkkk não tenho permissão de mudar. adicionado 24 minutos depois Vamos esquecer o devolverNó, e se eu fosse interpretar dessa forma: 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 ?

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 ? 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. adicionado 3 minutos depois E consegui arrumar alguns erros básicos de ponteiros no código.

Agradeço as respostas e novamente obrigado, estou corrigindo aos poucos e entendendo também.

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. Um ponteiro não pode apontar para uma variável do tipo float ? será que é isso problema de semântica ?

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; }

Arfneto muito obrigado pela dica.

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; 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; }