void pruebas_heap_alumno(){
heap_t* heap = heap_crear(func_comp);
print_test("El heap esta vacio", heap_esta_vacio(heap));
print_test("Ver max del heap es NULL", heap_ver_max(heap) == NULL);
int a = 5, b = 6, c = 8, d = 7, e = 10;
print_test("Encolo el primer elemento (a)",heap_encolar(heap, &a));
print_test("El maximo del heap es a ",heap_ver_max(heap) == &a);
print_test("Encolo el segundo elemento (b)", heap_encolar(heap,&b));
print_test("El maximo del heap es el segundo elemento (b): ", heap_ver_max(heap) == &b);
print_test("La cantidad del heap es 2", heap_cantidad(heap) == 2);
print_test("Encolo el tercer elemento (c): ", heap_encolar(heap,&c));
print_test("El maximo del heap es el tercer elemento (c)", heap_ver_max(heap) == &c);
print_test("Encolo el cuarto elemento (d) ", heap_encolar(heap,&d));
print_test("El maximo del heap sigue siendo el tercer elemento (c)", heap_ver_max(heap) == &c);
print_test("La cantidad del heap es 4", heap_cantidad(heap) == 4);
print_test("Encolo el quinto elemento (e) ", heap_encolar(heap, &e));
print_test("El maximo del heap es el quinto elemento", heap_ver_max(heap) == &e);
print_test("Desencolo", heap_desencolar(heap) == &e);
print_test("Desencolo", heap_desencolar(heap) == &c);
print_test("Desencolo", heap_desencolar(heap) == &d);
print_test("Desencolo", heap_desencolar(heap) == &b);
print_test("Desencolo", heap_desencolar(heap) == &a);
print_test("El heap esta vacio", heap_esta_vacio(heap));
//pruebas_heapify();
//pruebas_heapsort();
//pruebas_heap_crear_arr();
heap_destruir(heap,NULL);
}
void downheap(heap_t* heap, int i, int fin) {
if (heap==NULL) return;
if (heap_esta_vacio(heap)) return;
int izq=2*i+1;
int der=2*i+2;
int maslargo=i;
if (fin >= izq+1){ //verifica que tiene hijos
if (fin == izq+1) //caso en el que tiene solo hijo izq
{
if (heap->cmp(heap->datos[i],heap->datos[izq])<0)
swap(&heap->datos[i],&heap->datos[izq]);
}
else{ //tiene los 2 hijos
if (heap->cmp(heap->datos[i],heap->datos[izq])<0)
maslargo=izq;
if (heap->cmp(heap->datos[maslargo],heap->datos[der])<0)
maslargo=der;
if (maslargo != i){
swap(&heap->datos[i],&heap->datos[maslargo]);
downheap(heap,maslargo,fin);
}
}
}
}
int listar_fabricas(base_t* base,bool imprimir){
int hora,minutos;
fabrica_t* fabrica;
fabrica_t* anterior;
if (lista_esta_vacia(base->fabricasavisitar)){
//creo una lista con las fabricas que voy a visitar
anterior = heap_desencolar(base->cerradofabricas);
lista_insertar_ultimo(base->fabricasavisitar,(void*)anterior);
while (!heap_esta_vacio(base->cerradofabricas)){
fabrica = heap_desencolar(base->cerradofabricas);
if (fabrica->horarioentrada>=anterior->horariosalida){
lista_insertar_ultimo(base->fabricasavisitar,(void*)fabrica);
anterior = fabrica;
}
}
}
if (imprimir){
printf("Cantidad: %zu\n",lista_largo(base->fabricasavisitar));
lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar);
while(!lista_iter_al_final(iterador)){
fabrica = lista_iter_ver_actual(iterador);
conversion_horario(&hora,&minutos,fabrica->horarioentrada);
printf("%s,%02d:%02d,",fabrica->idfabrica,hora,minutos);
conversion_horario(&hora,&minutos,fabrica->horariosalida);
printf("%02d:%02d\n",hora,minutos);
lista_iter_avanzar(iterador);
}
lista_iter_destruir(iterador);
}
return 0;
}
/* Elimina el elemento con máxima prioridad, y lo devuelve.
* Si el heap esta vacío, devuelve NULL.
* Pre: el heap fue creado.
* Post: el elemento desencolado ya no se encuentra en el heap.
*/
void *heap_desencolar(heap_t *heap){
if (heap_esta_vacio(heap)) return NULL;
void* elem_max = heap->datos[0];
heap->datos[0] = heap->datos[--heap->cant];
downheap(heap->datos, heap->cant, 0, heap->heap_cmp);
if (heap->tam / 2 > TAM_INICIAL && heap->cant < heap->tam * FACTOR_MIN)
heap_redimensionar(heap, heap->tam / 2);
return elem_max;
}
void *heap_desencolar(heap_t *heap){
if (heap==NULL) return NULL;
if (heap_esta_vacio(heap)) return NULL;
void* aux=heap->datos[0];
//cambio la raiz por la ultima hoja,la borro, y hago downheap con la nueva raiz.
heap->datos[0]=heap->datos[heap->cantidad-1];
heap->datos[heap->cantidad-1]=NULL;
heap->cantidad--;
downheap(heap,0,heap->cantidad);
return aux;
}
void *heap_ver_max(const heap_t *heap){
if (heap==NULL) return NULL;
if(heap_esta_vacio(heap)) return NULL;
return (heap->datos[0]);
}