Lucas LC

Boa noite pessoal! Gostaria de saber a diferença entre o Rjava e o Rcaller, pelo que eu entendi, ambos fornece funções do R para ser executado no Java, já que possui uma interface de alto nível.

Bom dia! Não sou novo em Java, já programa a 2 anos nessa linguagem e estou com um projeto no momento, mas estou sem ideias, preciso criar um programa que envolva a camada de aplicação (aquela que é explicada em redes de computadores), essa camada é a ponte entre o usuário e o programa promovendo uma interface, então quando solicitamos um serviço a um servidor a camada que nós teremos contato primeiro é a camada de aplicação, então estou sem ideias de programas a ser feito no Java que envolva essa camada especifica, alguém tem alguma ideia ?

Pessoal, boa noite! Preciso de ajuda, estou querendo criar um banco de dados, usando Java principalmente, já fiz um banco de dados na mão mesmo, criei uma árvore B em arquivo e adicionava alguns dados nessa árvore B e excluía, consultava etc..., mas quero melhorar e criar um de verdade, usando o SQL ou MYSQL, que são SGBD, alguém conhece um artigo sobre isso, ou pode me orientar com algumas dicas.

Boaa, ajudou sim, obrigado cara.

Bom dia! Estou fazendo um programa de agendamento de reuniões e não posso usar operações tipo: (11/02/2020 < 11/03/2020) porque são Strings, queria saber se tem algum método ou forma de saber se uma data for menor q a outra ou maior e então retornar que não vai ter reunião neste dia. E também, estou trabalhando com um tipo de lista que é o TreeMap e quero encontrar o horário e data que mais se repetiu nessa lista: private TreeMap<String, LocalDateTime[]> disponibilidades = new TreeMap<>(); LocalDateTime - quarta todas as horas e datas preenchidas pelos participantes; String - Identificação do participante.

Na verdade, nem sabia que eu estava usando classes q não são nativa do Java. Ah beleza, obrigado!

Boa tarde! Alguém conhece a criptografia no java ? Estou tentando usar a classe BasicPasswordEncryptor, mas parece que não existe. package org.jasypt.util.password; import org.jasypt.util.password.BasicPasswordEncryptor; class Main { public static void main(String[] args) { BasicPasswordEncryptor encryptor = new BasicPasswordEncrypto(); String senhaCriptografada = encryptor.encryptPassword("senha123"); System.out.println(senhaCriptografada); } }

Obrigado Adriano, acho que consegui terminar. Obrigado pela ajuda.

Consegui fazer meu explorador percorrer todo o labirinto e imprimir todos os caminhos possíveis, agora preciso separar entre aquele mais curto e mais longo. Esse tabuleiro tem apenas 3 caminhos possíveis: (x,y): (6, 2) (x,y): (5, 2) (x,y): (4, 2) (x,y): (3, 2) (x,y): (2, 2) (x,y): (1, 2) (x,y): (0, 2) Tamanhos 7 Destino Encontrado!! (x,y): (6, 2) (x,y): (6, 1) (x,y): (6, 0) (x,y): (5, 0) (x,y): (4, 0) (x,y): (3, 0) (x,y): (2, 0) (x,y): (1, 0) (x,y): (0, 0) (x,y): (0, 1) (x,y): (0, 2) Tamanhos 11 Destino Encontrado!! (x,y): (6, 2) (x,y): (6, 3) (x,y): (6, 4) (x,y): (5, 4) (x,y): (4, 4) (x,y): (3, 4) (x,y): (2, 4) (x,y): (1, 4) (x,y): (0, 4) (x,y): (0, 3) (x,y): (0, 2) Tamanhos 11 Destino Encontrado!! Toda vez que ele chega no destino ele imprime essa mensagem. Essa é a parte do código que ele para quando encontra todos os caminhos e o switch que valida conforme o critério. A outra parte do código é movimento esquerda, baixo, direita e cima. Preciso validar agora com base nos críterios colocando esse objeto solucaoAtual recebendo todos os caminhos possíveis e chamar no critério1 por exemplo, ai fica assim: public void criterio1(Solucao solucao){ if(melhor == null || solucao.tamanho() < melhor.tamanho()){ melhor = clone(solucao); } } esse objeto melhor vale null no primeiro caso e depois faço uma cópia do objeto solucao para não modificar o endereço do objeto que tá lá naquele método que se movimenta. No entanto eu fiz um println e ele não faz mais comparações com o segundo caminho que é aquele que tem tamanho 11, será que eu preciso armazenar as cópias dos caminhos em um array ou faço uma outra lista para isso ?

Adriano boa noite! Consegui fazer bastante coisa já e arrumei muitas coisas no código, será que você pode me ajudar com uma dica sobre cópia de objetos ?

Vou dar uma olhada sim, obrigado!

Adriano boa tarde! Será que você pode me ajudar a fazer o primeiro caminho, que é o caminho com menor casas. Deixei todos os arquivos que eu fiz em anexo. O primeiro caminho tentei colocar um if como caso base para parar a recursão do atributo solucao, fiz um while para ele andar no labirinto, enquanto meu explorador puder ir para cima, baixo, esquerda e direita ele continua, chamo a função movimentar() para dar um passo, programei para ele ir para cima primeiro, adiciono esse movimento na lista que você me ajudou a fazer, zero as direções para ele tentar ir para cima de novo, ai nos próximos ifs fiquei meio perdido, porque preciso ter um caminho diferente para comparar ai fiz esse atributo solucao para comparar com a melhor, por isso chamei recursivamente e depois comparo o tamanho delas e retorno o caminho melhor. Solucao.txt.txtPosicao.txt.txtMovimentoExplorador.txt.txtMain.txt.txtGame.txt.txtCriterios.txt.txt

Entendi, obrigado!!

Ata, pensei em inicializar uma variável com 0 e meu for percorre a lista, cada vez que ela achar um objeto ela incrementa e retorna o tamanho.

Entendi, obrigado mesmo pela ajuda. ficou assim então: Assim eu consigo fazer o histórico das coordenadas que chegou até o final do caminho certo ? Ai eu só comparo o tamanho dessas listas para ver qual é a menor ou maior.

Boa tarde amigo. Eu fiz a classe solução igual a sua ideia, queria saber se tá certo. A classe Posição é instanciada no método main colocando a posição inicial e final. O getPosX() e getPosY() marca a posição atual do explorador. CLASSE SOLUÇÃO PARA REGISTRAR O HISTÓRICO DE COORDENADAS. CLASSE POSIÇÃO.

Olá bom dia! Gostaria de uma ajuda. Estou fazendo um labirinto em java, a ideia principal é que um explorador está nesse labirinto e ele pode se movimentar em 4 direções(cima,baixo,direita e esquerda), até chegar no seu destino. Preciso implementar 4 caminhos para o meu labirinto, segue abaixo: 1. Caminho mais curto. Isto é, que passe pelo menor número possível de casas. 2. Caminho mais longo. Isto é, que passe pelo maior número possível de casas (ok, este é um critério estranho, mas pense que o explorador possui motivos para visitar o maior número de casas possível sem passar mais de uma vez por uma mesma casa). 3. Caminho mais valioso. Isto é, que maximiza o valor dos itens coletados. 4. Caminho mais rápido. Ou seja, aquele minimiza o tempo que se leva para chegar no destino (note que não necessariamente equivale ao mais curto, pois depende dos itens que são coletados no caminho, o que por sua vez afeta o tempo necessário para percorrê-lo). Para fazer esses caminhos eu fiz um método movimentar, retornarMovimento (caso não dê as 4 direções ele retorna uma casa). private void aumentarDirecoes() { this.direcoes += 1; } public void movimentar() { //Parar caso não de as 4 direções. if(this.direcoes >= 4) return; Posicao retornarMovimento = retornarMovimento(); //saber o local que ele está. String valor = this.game.retornarValorPosicaoLabirinto(retornarMovimento); //Caso o valor retornado seja o do próprio explorador ou a passagem esteja bloqueada não faça nada ou entrou um item. if(valor.equals("X")) { proximoMovimento(); aumentarDirecoes(); //Se não de certo tente novamente. movimentar(); } else { this.posInicial = retornarMovimento; } } private void proximoMovimento() { switch(this.movimento) { case CIMA: this.movimento = MovimentoExplorador.BAIXO; break; case BAIXO: this.movimento = MovimentoExplorador.ESQUERDA; break; case ESQUERDA: this.movimento = MovimentoExplorador.DIREITA; break; case DIREITA: this.movimento = MovimentoExplorador.CIMA; break; } } //Em um algoritmo de tentativa e erro, sempre tem a possibilidade de retornar o movimento que não dá certo. public Posicao retornarMovimento() { int retornoPosX = this.posInicial.getPosX(); int retornoPosY = this.posInicial.getPosY(); //Caso o explorador for para cima, para retornar uma posição ele precisa ser maior que 0. switch(movimento) { case CIMA: if(retornoPosX > 0) { retornoPosX -= 1; } break; case BAIXO: if(retornoPosX < this.game.getLines() -1){ retornoPosX +=1; } break; case ESQUERDA: if(retornoPosY > 0) { retornoPosY -= 1; } break; case DIREITA: if(retornoPosY < this.game.getColumn() -1){ retornoPosY += 1; } break; } return new Posicao(retornoPosX, retornoPosY); } Esse método movimento ele faz apenas 1 movimento, logo na implementação do primeiro caminho para encontrar o menor número de casas eu pensei em criar uma classe que adicione as coordenadas desse movimento, mas é claro vou precisar mudar esse método movimentar para retornar as coordenadas que ele foi, então toda vez que ele fizer um movimento ele adiciona as coordenadas na outra classe e depois eu só comparo os tamanhos das listas para encontrar a menor, porém para fazer isso pensei em usar um arraylist, mas não sei como utilizar perfeitamente, alguém poderia ajudar ?

Bom dia pessoal! Tenho que implementar um labirinto com 4 caminhos possíveis, sendo eles: 1. Caminho mais curto. Isto é, que passe pelo menor número possível de casas. 2. Caminho mais longo. Isto é, que passe pelo maior número possível de casas (ok, este é um critério estranho, mas pense que o explorador possui motivos para visitar o maior número de casas possível sem passar mais de uma vez por uma mesma casa). 3. Caminho mais valioso. Isto é, que maximiza o valor dos itens coletados. 4. Caminho mais rápido. Ou seja, aquele minimiza o tempo que se leva para chegar no destino (note que não necessariamente equivale ao mais curto, pois depende dos itens que são coletados no caminho, o que por sua vez afeta o tempo necessário para percorrê-lo). O labirinto é representado por uma matriz e a movimentação pelo labirinto pode se dar em 4 direções: para cima, para baixo, para a esquerda e para a direita. Um caminho que leva o explorador da origem ao destino só pode passar por cada posição uma única vez. Esses 4 caminhos preciso fazer usando a definição de um algorítmo de tentativa e erro. Gostaria de saber se alguem tem alguma ideia de como fazer os caminhos ou se tem alguma página na net que conheça sobre o assunto.

porque isso iria contra todo o princípio de objetos, encapsulamento e o princípio de não reinventar coisas. O arranjo correspondente ao heap não fica ordenado, por isso não precisamos do método heapSort em si: o arranjo corresponderá ao heap máximo: cada elemento terá prioridade maior ou igual à prioridade de seus filhos, mas não necessariamente será um arranjo ordenado.

Desculpa por sumir, estava com alguns problemas. Então fiz sim maxHeap que chama uma função MaxHeapfy que faz essa manutenção, por exemplo: caso o elemento incluído no última posição ele é inserido e colocado na posição correta no heap usando a prioridade dele, a fila de prioridade fina no arranjo de ponteiros que guarda o endereço de todos os elementos inseridos, o heap seria uma forma de implementar os dois ao mesmo tempo esse trabalho. Consegui fazer já e está funcionando corretamente, colocarei no GitHub e mostrarei para você depois. De acordo com o meu orientador não precisa de heapsort. Entendi arfneto, obrigado pelas dicas.

Na verdade eu simplesmente tirei aquela parte e deixei a variável posição em 0, fiz a verificação da fila, se ela está vazia sim ou não, coloquei o endereço da primeira posição no ponteiro atual, decrementei o f->elementosNoHeap, coloquei o último elemento na primeira posição e chamei a reduzirPrioridadeAux, organizando meu heap. PONT removerElemento(PFILA f){ PONT res = NULL; int id; PONT atual; int posicao = 0; //Verificar se a fila não está vazia. if(f == NULL) return res; if(f->elementosNoHeap == 0) return res; //A primeira posição precisa ser excluida. atual = f->heap[0]; f->elementosNoHeap--; f->heap[0] = f->heap[f->elementosNoHeap]; reduzirPrioridadeAux(f,0); //Colocar NULL na posição do arranjo. int excluir = atual->id; f->arranjo[excluir] = NULL; res = atual; return res; } Nesse programa o heap corresponde a um ponteiro para um arranjo de ponteiros para elementos do tipo ELEMENTO, este arranjo representará o heap máximo, seu tamanho será igual a maxElementos e o campo elementosNoHeap determinará quantos elementos válidos estão no heap em um dado momento e o arranjo corresponde a um ponteiro para um arranjo de ponteiros para elementos do tipo ELEMENTO, que irá guardar todos os elementos inseridos, a estrutura heap vai ter alguns métodos para fazer a manutenção dessa estrutura como esses dois que eu fiz : Esse aumentarPrioridadeAux2 será usando quando eu inserir um elemento na última posição ou aumentar a prioridade de algum elemento no arranjo e heap e preciso colocar ele no lugar certo do heap máximo, caso sua prioridade seja maior e o reduzirPrioridadeAux uso ele em reduzir prioridade para descer o elemento que tiver prioridade menor que seus filhos e caso o 1 elemento do heap seja excluido, ai eu excluo do heap e arranjo. exemplo: //Função para trocar a posição dos elementos no heap. void troca(PONT* a, PONT* b){ PONT t = *a; *a = *b; *b = t; } //Se o atual tiver prioridade maior do que a de seu pai, os dois devem trocar de lugar). void aumentarPrioridadeAux2(PFILA f, PONT atual){ int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(atual->prioridade > f->heap[(i-1)/2]->prioridade){ troca(&(atual), &(f->heap[(i-1)/2])); } } } //Descer elemento no Heap void reduzirPrioridadeAux(PFILA f, int posicao){ int maiorFilho = -1; for (posicao=0;posicao<f->elementosNoHeap;posicao++){ if(2*posicao+1 < f->elementosNoHeap){ maiorFilho = 2*posicao+1; if(2*posicao+2 < f->elementosNoHeap && (f->heap[2*posicao+1]->prioridade) < (f->heap[2*posicao+2]->prioridade)) maiorFilho = 2*posicao+2; if(maiorFilho>-1 && f->heap[posicao]->prioridade < f->heap[maiorFilho]->prioridade) { troca(&(f->heap[posicao]), &(f->heap[maiorFilho])); } } } } Não sei se deu para entender agora, o que estou com problemas é nessa função de troca, ele pode até trocar elementos de lugar, mas eles não trocam de posição.

Não foi inicializado no método nessa parte eu já mudei, me equivoquei. Exatamente, ele não entra na definição de pilha e sim de uma árvore quase completa. Sim, PFILA é um ponteiro da fila de prioridade. E também a estrutura não pode ser mudada. Sim entendi, na verdade eu até me acostumei de usar typedefs como ponteiros.

Ok, vou colocar as informações que estou usando para executar. filaDePrioridade.txt usaFilaDePrioridade.txt Coloquei as referências usadas e o arquivo de teste. A inserção está correta. Quando uso a função void aumentarPrioridadeAux2(PFILA f, PONT atual), ela aumenta a prioridade, mas não corretamente, tentei fazer isso usando o PONT atual, o int posicao e até uma função recursiva, fazendo o mesmo trabalho. A mesma coisa acontece em diminuir prioridade. Enunciado- heap.docx

Boa noite! Estou fazendo uma fila de prioridade heap, são dois vetores de ponteiros que guardam os elementos inseridos, o método de inserir consegui fazer, mas as outras não consegui muito bem, gostaria de algumas dicas, criei alguns métodos auxiliares para fazer a manutenção da estrutura heap que são: refazHeapMaximo, maxHeapify, aumentarPrioridadeAux, reduzirPrioridadeAux. As duas últimas são subir heap, quando a prioridade de um elemento é modificada ele precisa subir na árvore e o descer é quando sua prioridade diminui. A estrutura heap é uma árvore que tem 2 filhos e 1 pai, os dois filhos precisam ser menores que seu pai, por isso essas funções auxiliares. No método aumentar prioridade, reduzir prioridade e remover, está em um loop infinito . Se alguém puder ajudar agradeço. PFILA criarFila(int max){ PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE)); res->maxElementos = max; res->arranjo = (PONT*) malloc(sizeof(PONT)*max); res->heap = (PONT*) malloc(sizeof(PONT)*max); int i; for (i=0;i<max;i++) { res->arranjo[i] = NULL; res->heap[i] = NULL; } res->elementosNoHeap = 0; return res; } void exibirLog(PFILA f){ printf("Log [elementos: %i]\n", f->elementosNoHeap); PONT atual; int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; printf("[%i;%f;%i] ", atual->id, atual->prioridade, atual->posicao); } printf("\n\n"); } //Função para trocar a posição dos elementos no heap. void troca(PONT* a, PONT* b){ PONT t = *a; *a = *b; *b = t; } //Posição do filho a esquerda é 2i+1, direita 2i+2, (i-1)/2 é o pai e o 0 é a raiz. void maxHeapify(PFILA f, PONT atual, int posicao){ int esquerda = 2*posicao+1; int direita = 2*posicao+2; int max; //Propriedade para fazer a manutenção da árvore. if(esquerda <= f->maxElementos && f->heap[esquerda]->prioridade > f->heap[posicao]->prioridade ){ max = esquerda; } else { max = posicao; } if(direita <= f->maxElementos && f->heap[direita]->prioridade > f->heap[max]->prioridade){ max = direita; } //Fazer a troca do elemento na posição maior. if(max != posicao){ atual = f->heap[posicao]; f->heap[posicao] = f->heap[max]; f->heap[max] = atual; maxHeapify(f,atual,max); } return; } //Será usado quando removemos um elementos ou reduzimos sua prioridade. //Árvore binária quase completa em que cada pai é maior ou igual que qualquer de seus filhos. void refazHeapMaximo(PFILA f, PONT atual){ //Decrescendo para encontrar o maior valor para a manutenção da árvore. for(int posicao=f->maxElementos/2;posicao>=0;posicao--){ atual = f->heap[posicao]; if(atual->prioridade > f->heap[(posicao-1)/2]->prioridade){ maxHeapify(f,atual,posicao); } } } //Sobe no Heap, função interativa void aumentarPrioridadeAux(PFILA f, int posicao){ int i = posicao; //Caso o pai seja menor que seus filhos. while(i > 0 && f->heap[(i-1)/2]->prioridade < f->heap[i]->prioridade) { troca(&(f->heap[i]), &(f->heap[(i-1)/2])); i = (i-1)/2; } } //Se o atual tiver prioridade maior do que a de seu pai, os dois devem trocar de lugar). void aumentarPrioridadeAux2(PFILA f, PONT atual){ int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(atual->prioridade > f->heap[(i-1)/2]->prioridade){ troca(&(atual), &(f->heap[(i-1)/2])); } } } //Descer elemento no Heap void reduzirPrioridadeAux(PFILA f, int posicao){ int maiorFilho; for (posicao=0;posicao<f->elementosNoHeap;posicao++){ if(2*posicao+1 < f->maxElementos){ maiorFilho = 2*posicao+1; if(2*posicao+2 < f->maxElementos && (f->heap[2*posicao+1]->prioridade) < (f->heap[2*posicao+2]->prioridade)) maiorFilho = 2*posicao+2; if(f->heap[posicao]->prioridade < f->heap[maiorFilho]->prioridade) { troca(&(f->heap[posicao]), &(f->heap[maiorFilho])); } } } } void reduzirPrioridadeAux2(PFILA f, PONT atual){ int maiorFilho; int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; if(2*i+1 < f->maxElementos){ maiorFilho = 2*i+1; atual = f->heap[maiorFilho]; if(2*i+2 < f->maxElementos && (f->heap[2*i+1]->prioridade) < (f->heap[2*i+2]->prioridade)) maiorFilho = 2*i+2; atual = f->heap[maiorFilho]; if(f->heap[i]->prioridade < atual->prioridade) { troca(&(f->heap[i]), &(atual)); } } } } //Quantidade de elementos no heap. int tamanho(PFILA f){ int tam = 0; for(int i=0; i<f->elementosNoHeap;i++){ tam++; } return tam; } bool inserirElemento(PFILA f, int id, float prioridade){ bool res = false; ELEMENTO* novoElemento; PONT atual; int posicao = f->elementosNoHeap; // posição inicial do novo elemento no arranjo chamado heap //id precisa ser válido e menor que maxElementos na estrutura. if(id < 0 || id >= f->maxElementos) return res; //Não incluir elementos repetidos. if(f->arranjo[id] != NULL) return res; atual = f->arranjo[id]; //Alocar memória para esse elemento. novoElemento = (PONT) malloc(sizeof(ELEMENTO)); //Guarde ele no arranjo de endereços. f->arranjo[id] = novoElemento; f->heap[f->elementosNoHeap] = novoElemento; // o novo elemento deve ser inserido na primeira posição livre do arranjo heap novoElemento->prioridade = prioridade; novoElemento->id = id; novoElemento->posicao = f->elementosNoHeap; f->elementosNoHeap++; aumentarPrioridadeAux(f,posicao); res = true; return res; } bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; PONT atual = f->arranjo[id]; if(f == NULL) return res; if (id < 0) return false; // id negativo if (id >= (f->maxElementos)) return res; //Verificar se os elementos do arranjo são válidos ou se tem alguém ou não. if (f->arranjo[id] == NULL) return res; // Caso a prioridade de um determinado elemento for maior que a variável passado como parâmetro retorne false. if (f->arranjo[id]->prioridade >= novaPrioridade) return res; atual->prioridade = novaPrioridade; aumentarPrioridadeAux2(f,atual); res = true; return res; } bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; PONT atual = f->arranjo[id]; if(f == NULL) return res; if (id < 0) return false; // id negativo if (id >= (f->maxElementos)) return res; // id > maximo // Se não tem na fila retorne false. if (f->arranjo[id] == NULL) return res; // Caso a prioridade de um determinado elemento for menor que a variável passado como parâmetro retorne false. if (f->arranjo[id]->prioridade <= novaPrioridade) return res; atual->prioridade = novaPrioridade; reduzirPrioridadeAux2(f,atual); refazHeapMaximo(f,atual); res = true; return res; } PONT removerElemento(PFILA f){ PONT res = NULL; int id; PONT atual = f->arranjo[id]; int posicao; //Verificar se a fila não está vazia. if(f == NULL) return res; if(f->maxElementos == 0) return res; for(posicao = f->elementosNoHeap;posicao >= 0; posicao--) //A primeira posição precisa ser excluida. if(posicao == 0) atual = f->heap[posicao]; f->elementosNoHeap--; f->heap[posicao] = f->heap[f->elementosNoHeap]; reduzirPrioridadeAux(f,0); //Colocar NULL na posição do arranjo. int excluir = atual->id; f->arranjo[excluir] = NULL; refazHeapMaximo(f,atual); res = atual; return res; } bool consultarPrioridade(PFILA f, int id, float* resposta){ bool res = false; if(f == NULL) return res; if (id < 0) return res; // id negativo if (id >= (f->maxElementos)) return res; if (f->arranjo[id] == NULL) return res;//Se os elementos da fila for válido. *resposta = f->arranjo[id]->prioridade;//Colocar na memória o valor da prioridade. res = true; return res; }

Boa noite! Implementei alguns meses atrás uma fila de prioridade, agora preciso dar um level up no código implementando com HEAP MÁXIMO que é uma árvore binária na qual a prioridade de um nó sempre será maior ou igual à prioridade de seus filhos. O heap é representando utilizando um arranjo e não é necessário que cada elemento possua um ponteiro para seu filho a esquerda, a direita ou para seu pai, pois, a partir da posição de um elemento no arranjo sabemos onde está seu pai e seus filhos (se existirem). Eu tenho essas funções para implementar: Mas antes disso, estou fazendo as funções auxiliares para fazer essas implementações mais complexas, gostaria que alguém desse algumas dicas e se está certo. Primeiro fiz um maxHeapify, ele faz a manutenção da árvore, ou seja ele faz a troca dos elementos da árvore para ela ter caracteristicas de uma árvore binária HEAP. Segundo uma função de troca com ponteiros, um heap sobe para subir a posição dos elementos caso sua prioridade aumente, um heap desce caso sua prioridade diminua e por último um maxHeap para chamar o maxHeapify, o maxHeap é para criar um vetor que tenha as propriedades de heap, então vou fazer as chamadas para ele ficar certinho. A fila não possui ponteiros para próx e nem ant, estou usando isso para saber a posição. Para um determinado elemento i: ­ pai de i é i/2 ­ filho esquerdo é i*2 ­ filho direito de i*2 + 1 Esses valores eu arredondei. O código está assim: fila.h #include <stdlib.h> #include <stdio.h> #define true 1 #define false 0 typedef int bool; typedef struct { int id; float prioridade; int posicao; } ELEMENTO, * PONT; typedef struct { int maxElementos; int elementosNoHeap; PONT* heap; 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); //Auxiliares void reduzirPrioridadeAux(PFILA f, int posicao); void reduzirPrioridadeAux2(PFILA f, PONT atual); void aumentarPrioridadeAux(PFILA f, int posicao); void aumentarPrioridadeAux2(PFILA f, PONT atual); void refazHeapMaximo(PFILA f, PONT atual); Fila.c #include "filaDePrioridade.h" PFILA criarFila(int max){ PFILA res = (PFILA) malloc(sizeof(FILADEPRIORIDADE)); res->maxElementos = max; res->arranjo = (PONT*) malloc(sizeof(PONT)*max); res->heap = (PONT*) malloc(sizeof(PONT)*max); int i; for (i=0;i<max;i++) { res->arranjo[i] = NULL; res->heap[i] = NULL; } res->elementosNoHeap = 0; return res; } void exibirLog(PFILA f){ printf("Log [elementos: %i]\n", f->elementosNoHeap); PONT atual; int i; for (i=0;i<f->elementosNoHeap;i++){ atual = f->heap[i]; printf("[%i;%f;%i] ", atual->id, atual->prioridade, atual->posicao); } printf("\n\n"); } //Posição do filho a esquerda é 2i, direita 2i+1 e i/2 é o pai. void maxHeapify(PFILA f, PONT atual, int posicao){ int esquerda = 2*posicao; int direita = 2*posicao+1; int max; //Propriedade para fazer a manutenção da árvore. if(esquerda <= f->elementosNoHeap && f->heap[esquerda] > f->heap[posicao] ){ max = esquerda; } else { max = posicao; } if(direita <= f->elementosNoHeap && f->heap[direita] > f->heap[max]){ max = direita; } //Fazer a troca do elemento na posição maior com sua posição inferior. if(max != posicao){ PONT aux = f->heap[posicao]; f->heap[posicao] = f->heap[max]; f->heap[max] = aux; maxHeapify(f,atual,max); } } //Função para trocar a posição dos elementos no heap. void troca(PONT* a, PONT* b){ PONT t = *a; *a = *b; *b = t; } //Sobe no Heap void aumentarPrioridadeAux(PFILA f, int posicao){ int i = posicao; //Caso o pai seja menor que seus filhos. while(i > 0 && f->heap[(i-1)/2] < f->heap[i]) { troca(&(f->heap[i]), &(f->heap[(i-1)/2])); i = (i-1)/2; } } //Descer elemento no Heap void reduzirPrioridadeAux(PFILA f, int posicao){ int p = posicao; while((2*p) < f->elementosNoHeap && (f->heap[2*p] > f->heap[p] || ((2*p+1) < f->elementosNoHeap && f->heap[2*p+1] > f->heap[p]))){ posicao = (2*p); if ((2*p+1) < f->elementosNoHeap && f->heap[2*p+1] > f->heap[posicao]) posicao = (2*p+1); troca(&(f->heap[p]), &(f->heap[posicao])); p = posicao; } } void refazHeapMaximo(PFILA f, PONT atual){ //Decrescendo para encontrar o maior valor para a manutenção da árvore. for(int posicao=f->elementosNoHeap/2;posicao>=0;posicao--){ atual = f->heap[posicao]; maxHeapify(f,atual,posicao); } } int tamanho(PFILA f){ int tam = 0; for(int i=0; i<f->elementosNoHeap;i++){ tam++; } return tam; } bool inserirElemento(PFILA f, int id, float prioridade){ bool res = false; /* COMPLETAR */ return res; } bool aumentarPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; /* COMPLETAR */ return res; } bool reduzirPrioridade(PFILA f, int id, float novaPrioridade){ bool res = false; /* COMPLETAR */ return res; } PONT removerElemento(PFILA f){ PONT res = NULL; /* COMPLETAR */ return res; } bool consultarPrioridade(PFILA f, int id, float* resposta){ bool res = false; /* COMPLETAR */ return res; }