void pruebas_cola_de_pilas() { printf("\nINICIO DE PRUEBAS CON COLA DE PILAS\n"); /* Declaro las variables a utilizar*/ cola_t* cola = cola_crear(); pila_t* pila = pila_crear(); pila_t* pila2 = pila_crear(); int a = 1, b = 2, c = 3, d = 4, e = 5; int* p_a = &a; int* p_b = &b; int* p_c = &c; int* p_d = &d; int* p_e = &e; /* Inicio de pruebas */ // Apilo todos los elementos pila_apilar(pila, p_a); pila_apilar(pila, p_b); pila_apilar(pila, p_c); pila_apilar(pila2, p_d); pila_apilar(pila2, p_e); // Encolo las pilas print_test("Prueba encolar pila 1", cola_encolar(cola, pila)); print_test("Prueba encolar pila 2", cola_encolar(cola, pila2)); /* Destruyo la cola */ cola_destruir(cola, pila_destruir_wrapper); print_test("La cola fue destruida", true); }
pila_t* mostrar_enviados(pila_t* pila, vector_t *vectorzonas, vector_t* vectorprecios){ pedido_t* pedido; pila_t * pila_nueva=pila_crear(); pila_t *pila_aux=pila_crear(); int recaudado=0; printf ("\n"); printf ("Los pedidos que fueron enviados, en orden del mas reciente al mas antiguo, son: \n"); printf ("\n"); while (!pila_esta_vacia(pila)){ pedido=pila_desapilar(pila); int* precio= (int*) vector_obtener(vectorprecios, pedido->zona-1); recaudado+=( (*precio) *(pedido->cantidad)); pila_apilar(pila_aux, pedido); printf("Pedido: %s Cantidad: %d Zona: %d \n",pedido->nombre,pedido->cantidad,pedido->zona); } printf("\n\n"); printf("Lo recaudado en total en los ultimos envios: $ %d\n", recaudado); while (!pila_esta_vacia(pila_aux)){ pila_apilar(pila_nueva, pila_desapilar(pila_aux)); } pila_destruir(pila_aux); pila_t *piladestruir=pila; if (piladestruir) pila_destruir(piladestruir); return pila_nueva; }
void posfijo(char *colaE,pila_tipo_dato *pilaOP, char *numactual,int fin_linea ){ char oper='\0'; //auxiliar int Boolinsert=0; char sep='#'; if (esOperador(numactual)==0){ //quiere decir que es operando o numero if (fin_linea==1){ //simbolo terminal while(pilaOP->cant_element!=0){ char quitar; pila_desapilar(pilaOP,&quitar); strcat(colaE,&quitar); } } else{ strcat(colaE,numactual); strcat(colaE,&sep); } } if(esOperador(numactual)==1) { //3.1) Si la pila esta vacía o el operador tiene mayor prioridad //que el que está en la cima de la pila (o bien es la máxima prioridad), //se mete en la pila. if (pilaOP->cant_element>0){ pila_getfrente(pilaOP,&oper); if (precedencia(numactual)>precedencia(&oper)){ pila_apilar(pilaOP,numactual); Boolinsert=1; } } if (pilaOP->cant_element==0){ pila_apilar(pilaOP,numactual); Boolinsert=1; } //3.2) Si la prioridad es menor o igual, el operador se saca de la pila, //se mete en la expresión postfija y se vuelve a hacer la comparación con //el nuevo elemento de la cima de la pila. if(Boolinsert==0 && pilaOP->cant_element>0) { pila_getfrente(pilaOP,&oper); while(precedencia(numactual)<=precedencia(&oper)&& pilaOP->cant_element>0 ){ char quitar; pila_desapilar(pilaOP,&quitar); strcat(colaE,&quitar); pila_getfrente(pilaOP,&oper); } pila_apilar(pilaOP,numactual); } } }
void auxiliar_creacion(abb_iter_t* iter,nodo_t* nodo){ if(!nodo){ return; } pila_apilar(iter->pila,nodo); auxiliar_creacion(iter,nodo->nodo_izquierdo); }
/* Almacenar en la pila de votacion el partido votado. Validar que exista ciclo de votacion. */ bool comando_votar_idPartido(maquina_votacion_t* maquina, char* id) { #ifdef DEBUG printf("Comando votar idPartido ejecutado \n"); #endif if(maquina->estado < VOTACION || (maquina->votando_cargo >= FIN) ) return error_manager(OTRO); long int idPartido_int = strtol(id, NULL, 10); if(idPartido_int < 1 || idPartido_int > maquina->cantidad_partidos) return error_manager(OTRO); voto_t* voto = malloc(sizeof(voto_t)); voto->partido_id = (size_t)strtol(id, NULL, 10); voto->cargo = maquina->votando_cargo; pila_apilar(maquina->ciclo, voto); maquina->votando_cargo++; imprimir_mensaje_ok(); if(maquina->votando_cargo < FIN) mostrar_menu_votacion(maquina); return true; }
void apilar_de_mayor_a_menor(pila_t* pila, abb_nodo_t* nodo) { if(!nodo) return; if(nodo->der != NULL) apilar_de_mayor_a_menor(pila, nodo->der); pila_apilar(pila, nodo); if(nodo->izq != NULL) apilar_de_mayor_a_menor(pila, nodo->izq); }
void ejecutar(pila_tipo_dato *pilaPos, char *res ){ pila_tipo_dato auxresult; pila_init(&auxresult); int error=0; char elemento[TAM_RES],result1[TAM_RES],result2[TAM_RES],resultOp[TAM_RES]; while(pilaPos->cant_element!=0) { //ceramos los vectores init_array(result1,TAM_RES); init_array(result2,TAM_RES); init_array(elemento,TAM_RES); init_array(resultOp,TAM_RES); pila_desapilar(pilaPos,elemento); //vemos si es operador if (esOperador(elemento)==1) { if ((auxresult.cant_element)<2){ res[0]=elemento[0]; strcat(res,"Error!!"); pilaPos->cant_element=0; error=1; //ocurrio un error } pila_desapilar(&auxresult,result1); pila_desapilar(&auxresult,result2); operar(result1, result2,elemento[0],resultOp); pila_apilar(&auxresult,resultOp); if(error==0){pila_getfrente(&auxresult,res);} } else{ pila_apilar(&auxresult,elemento); } } }
bool abb_iter_in_avanzar(abb_iter_t* iter){ if (abb_iter_in_al_final(iter)) return false; if (!iter->actual->der) iter->actual = pila_desapilar(iter->pila); else{ iter->actual = iter->actual->der; while (iter->actual->izq){ pila_apilar(iter->pila, iter->actual); iter->actual = iter->actual->izq; } } return true; }
abb_iter_t *abb_iter_in_crear(const abb_t *arbol){ // Si el arbol no existe if (!arbol) return NULL; abb_iter_t* iter = malloc(sizeof(abb_iter_t)); iter->pila = pila_crear(); abb_nodo_t* nodo = arbol->raiz; if (arbol->raiz){ while (nodo->izq){ pila_apilar(iter->pila, nodo); nodo = nodo->izq; } } iter->actual = nodo; return iter; }
void apilar_nodos(abb_iter_t* iter, abb_nodo_t* arbol){ if (!arbol) return ; pila_apilar(iter->pila, arbol); apilar_nodos(iter, arbol->izquierda); }
void enviar(vector_t * vectorzonas, pila_t* pila){ lista_iter_t *iter,*iterborrar; bool primeroencontrado; int i,canti,cantf,total; pedido_t *pedidoaux,*primerpedido,*pedidof; lista_t* listaaux; for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){ primeroencontrado=true; while(primeroencontrado) { primeroencontrado=false; canti=0; cantf=0; total=0; pedidof=NULL; listaaux= (lista_t*) vector_obtener(vectorzonas, i); iter=lista_iter_crear(listaaux); while ( !lista_iter_al_final(iter) ) { pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter)); if (pedidoaux !=NULL) { if ( (!primeroencontrado) && (pedidoaux->preparado)) { primerpedido=pedidoaux; //primer pedido es el primer pedido preparado de esa zona canti=pedidoaux->cantidad; primeroencontrado=true; } else if (pedidoaux->preparado) { cantf=pedidoaux->cantidad; if ( ((canti + cantf)<=5) && ((canti+cantf)>total) ) { pedidof=pedidoaux; total=canti+cantf; } } } lista_iter_avanzar(iter); } lista_iter_destruir(iter); if ( (primeroencontrado) && (pedidof!=NULL)) printf("Se envio el pedido %s junto con el pedido %s \n",primerpedido->nombre,pedidof->nombre); else if (primeroencontrado){ printf("Se envio el pedido %s \n",primerpedido->nombre); } iterborrar=lista_iter_crear(listaaux); while (!lista_iter_al_final(iterborrar)) { if ( primerpedido==lista_iter_ver_actual(iterborrar) ) { pila_apilar(pila,primerpedido); lista_borrar(listaaux,iterborrar); } else{ if (pedidof==lista_iter_ver_actual(iterborrar)) { pila_apilar(pila,pedidof); lista_borrar(listaaux,iterborrar); } else lista_iter_avanzar(iterborrar); } } lista_iter_destruir(iterborrar); } } }