예제 #1
0
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);
}
예제 #2
0
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;
}
예제 #4
0
파일: heap.c 프로젝트: ordonezf/algo2
/* 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;
}
예제 #5
0
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;
	}
예제 #6
0
void *heap_ver_max(const heap_t *heap){
	if (heap==NULL) return NULL;
	if(heap_esta_vacio(heap)) return NULL;
	
	return (heap->datos[0]);
	}