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