Lucas LC

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

Olá bom dia!
 
Estou implementando uma função de preenchimento e preciso de uma informação, no java é considerado em uma imagem o canto superior esquerdo que possui coordenadas (0,0), a partir desse ponto eu quero começar a pintar no lado esquerdo, lado direito, acima e abaixo, posso fazer assim : 
 
(0,y), (x,0), (y,y) e (x,x).   
 

Alguém poderia dar uma ajuda ou algumas dicas.
 
Preciso implementar um código que imprima uma curva de koch, como essa:
 

 
Fiz uma classe mãe que se chama Image, segue o código:    
import java.awt.*;     import java.awt.image.*;     import javax.imageio.*;     import java.io.*;     public class Image {         private int width, height;         private BufferedImage image;         private Graphics graphics;         private Color color;         private Color bgColor;         public Image(int w, int h, int r, int g, int b){             setup(w, h, r, g, b);         }         public Image(int w, int h){             setup(w, h, 0, 0, 0);         }         private void setup(int w, int h, int r, int g, int b){             image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);             width = image.getWidth();             height = image.getHeight();             graphics = image.createGraphics();                          setBgColor(new Color(limit(r), limit(g), limit(b)));             setColor(Color.WHITE);             clear();         }         private int limit(int value){             return value < 0 ? 0 : (value > 255 ? 255 : value);         }         public void setBgColor(Color c){             bgColor = c;         }         public void setBgColor(int r, int g, int b){             setBgColor(new Color(limit(r), limit(g), limit(b)));         }         public void setColor(Color c){             color = c;         }         public void setColor(int r, int g, int b){             setColor(new Color(limit(r), limit(g), limit(b)));         }         public void clear(){             graphics.setColor(bgColor);             graphics.fillRect(0, 0, width, height);         }         public void setPixel(int x, int y){                              if(x >= 0 && y >= 0 && x < width && y < height){                                  image.setRGB(x, y, color.getRGB());             }         }         public int getPixel(int x, int y){             return image.getRGB(x, y);          }         public void drawLine(int x1, int y1, int x2, int y2){             graphics.setColor(color);             graphics.drawLine(x1, y1, x2, y2);         }         public void save(String fileName){             try{                 ImageIO.write(image, "png", new File(fileName));             }             catch(IOException e){                          System.out.println("Unable to save image...");                 e.printStackTrace();             }         }     } Tenho outra classe que converte o arquivo txt em imagem e ela imprime uma paisagem sem nada, da uma olhada: 
 

 
Agora preciso implementar uma classe filha da curva de koch, porém não sei bem como fazer isso. Sendo que a implementação tem que  receber como parâmetros as coordenadas x e y dos pontos P e Q e o valor l do limiar.