int main(int argc, char const *argv[]){
int opc,tam;
char cont = 's';
int* lista;
while(cont == 's' || cont == 'S'){
switch(opc = menu()){
/** Crea una lsita de enteros */
case 1:
crearLista(&lista,&tam);
break;
/** Realiza el metodo Quicksort */
case 2:
quicksort(&lista, 0, tam-1);
printf("Quicksort completado!\n");
break;
/** Muestra la lista en el momento actual */
case 3:
mostrarLista(&lista,tam);
break;
/** finaliza el programa */
case 4:
printf("Hasta luego! :)\n");
cont = 'n';
break;
default:
printf("Opcion invalida\n");
break;
}
}
return 0;
}
void inicializarA(tabla_abierta t, int tamTabla) {
int i;
for (i = 0; i < tamTabla; i++) {
lista l;
crearLista(&l);
t[i] = l;
}
}
int main ()
{
FILE *pf;
int mat[TAM][TAM]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
t_lista lista;
t_dato dato;
dato.clave=-1;
pf=fopen("archivo.bin","rb+");
if(!pf)
{
printf("No se pudo abrir el archivo.");
exit(1);
}
printf("Los montos del arch. son: \n");
mostrarArch(pf);
pausa();
system("cls");
crearLista(&lista);
printf("Ingrese clave y monto (clave=0 para salir): \n");
scanf("%d %d",&dato.clave,&dato.monto);
while(dato.clave!=0)
{
if(!insertarEnLO(&lista,&dato))
printf("\nNo se pudo insertar.\n");
printf("\nIngrese clave y monto (clave=0 para dejar de cargar): \n");
scanf("%d %d",&dato.clave,&dato.monto);
}
system("cls");
printf("La lista es: \n\n");
mostrarLista(&lista);
pausa();
if(!elimSumarRepeLO(&lista))
{
printf("\nLista vacia. Cerrando Programa.");
pausa();
exit(1);
}
system("cls");
printf("Tras eliminar repetidos, la lista es: \n\n");
mostrarLista(&lista);
pausa();
buscarEnMat(mat,&lista,pf);
system("cls");
printf("Tras actualizar, el archivo queda: \n\n");
mostrarArch(pf);
fclose(pf);
pausa();
return 0;
}
int main()
{
FILE *fp;
Lista lista;
tInfo reg;
datos dato;
char prov[26];
printf("\t\t\t\t\tEJEMPLO DE PARCIAL\n\n");
printf("\t\t\t\t\tIngrese fecha y cantidad minima a evaluar\n");
if(!abrirArchivo(&fp,ARCHPROD,"r+b",!CON_SIN_MSJ))
{
crearArchivo(&fp);
if(!abrirArchivo(&fp,ARCHPROD,"r+b",CON_SIN_MSJ))
return 0;
}
crearLista(&lista);
do
{
printf("Fecha: ");
fflush(stdin);
scanf("%d/%d/%d",&dato.fcom.dia,&dato.fcom.mes,&dato.fcom.anio);
}while(!fechaValida(&dato.fcom));
printf("\nCantidad minima: ");
scanf("%d",&dato.stockMin);
fread(®,1,sizeof(reg),fp);
while(!feof(fp))
{
if(compararXfcomYstock(®,&dato))
actualizacionPrecio(&fp,®);
if(!listaLlena(&lista))
insertarPorFechaVentaYdescripcion(&lista,®,compararXfcomYDescrp);
fread(®,1,sizeof(reg),fp);
}
system("cls");
mostrarArchivo(&fp);
fclose(fp);
printf("\t\t\t\t\nIngrese el proveedor a eliminar de la lista: ");
fflush(stdin);
gets(prov);
eliminarDeLista(&lista,prov);
vaciarLista(&lista);
return 0;
}
/* Agrega la palabra clave 'p' en 'abb'.
En otro caso no hace nada. */
void agregarABB (ABB_T &abb, char* p) {
if (esVacioABB(abb)) {
ABB_T t = new AuxABB_T;
t->clave = new char[MAX_STR];
strcpy(t->clave, p);
t->izq = NULL;
t->der = NULL;
crearLista(t->lista);
abb = t;
} else {
if (strcmp(palabraClaveABB(abb), p) > 0) {
agregarABB(abb->izq, p);
} else if (strcmp(palabraClaveABB(abb), p) < 0) {
agregarABB(abb->der, p);
}
}
}
int main()
{ t_listaPartidos listaPartidos;
FILE *archivoPartidos=NULL;
archivoPartidos=fopen("partidos.txt","rt");
if(!archivoPartidos) {printf("no se puede abrir el archivo...");return 0;}
crearLista(&listaPartidos);
FILE *archivoBinario=NULL;
cargarPartidosEnLista(archivoPartidos,&listaPartidos);
mostrarListapartidos(&listaPartidos);
char *nombres[]={"AB","BE","CE","DE","PEPE","PEPITO","PEPAZO","BOCA","RIVER","SAN LORENZO","HIMAN","POPEYE","JACKOUBREY","YO","TU","EL",
"NOSOTROS","VOSOTROS","ELLOS","USTED","MIO","TUYO","FACTURAS","CON","CREMA"}; //el numero de agrupacion va del 0 al 24
//generarVotaciones(archivoBinario,"agrupaciones.bin","wb");
vaciarListaPartidos(&listaPartidos);
fclose(archivoPartidos);
return 0;
}
int main()
{
t_lista lista;
t_arbol arbol;
FILE* pf;
int op;
crearLista(&lista);
crearArbol(&arbol);
op=selecSimp();
pf=fopen("arbol.bin","rb");
cargarArbolDeArchivo(&arbol,&pf);
printf("Mostrando el arbol:\n");
preOrdenR(&arbol);
while(op!=4)
{
switch(op)
{
case 1: /*Cargar arbol en lista*/
arbolAListaDoble(&arbol,&lista,0);
printf("Presione una tecla para continuar...");
getch();
system("cls");
break;
case 2: /*Mostrar Lista*/
mostrarListaDoble(&lista);
printf("Presione una tecla para continuar...");
getch();
system("cls");
break;
case 3: /*Vaciar Lista*/
vaciarLista(&lista);
printf("Presione una tecla para continuar...");
getch();
system("cls");
break;
}
op=selecSimp();
printf("Mostrando el arbol:\n");
preOrdenR(&arbol);
}
vaciarLista(&lista);
eliminarArbol(&arbol);
fclose(pf);
return 0;
}
int expresionBalanceada(char expresion[]) // expression de parentesis los identifica
{
nodo *pilaAuxiliar;
int longitudExpresion, i;
char valor;
pilaAuxiliar=crearLista(pilaAuxiliar);
longitudExpresion = strlen(expresion);
for(i=0; i<longitudExpresion; i++)
{
if (expresion[i]== '(') // caracter //
pilaAuxiliar = push(expresion[i], pilaAuxiliar);
if(expresion[i]== ')') //caracter //
pilaAuxiliar = pop(&valor, pilaAuxiliar);
}
if (pilaAuxiliar == NULL)
return 1;
return 0;
}
/*
* Función que incerta ordenadamente en la lista
*/
lista* insertar(int id){
if(head == NULL){ //si la lista esta vacia, cree un nodo cabeza.
(crearLista(id));
}
lista* temporal = //head; creo un puntero temporal a la cabeza de la lista.
if(buscar(id) == true){ //busco si el nodo existe
while(temporal != NULL){ //si es así debo solamente aunemtar el contador de la cantidad del nodo
if(temporal-> identificador == id){
temporal->cantidad += 1;
return head; //termina la ejecucuón
}
temporal = temporal->siguiente;
}
}
// si el nodo no existe, debo asignar la memoria para el almacenamiento de este.
lista* ptr = (lista*)malloc(sizeof(lista));
if(NULL == ptr){
return NULL;
printf("Error al asignar la memoria\n");
}
//asigno los valores que concervan la información del puntero
ptr->identificador = id;
ptr->cantidad = 1;
ptr->siguiente = NULL;
//me preparo para insertar el nodo nuevo
lista *previo;
temporal = head->siguiente; //asigno 2 punteros, 1 al head y otro al siguiente
previo = head;
//digo que mientras no termine y no encuentre un id mayor al q voy a insertar
while(temporal != NULL && temporal->identificador < id) {
previo = temporal;
temporal = temporal->siguiente;
}
//inserto el nodo.
ptr->siguiente = temporal;
previo->siguiente = ptr;
return head;
}
//**********MAIN**********//
void main()
{
FILE* pf;
t_cola cola;
t_pila pila;
t_lista lista;
t_pedido ped;
t_producto prod;
int cont=1;
abrirArchivo(&pf,"r+b");
mostrarArchivo(pf);
crearCola(&cola);
crearPila(&pila);
crearLista(&lista);
printf("\nACOLAR\n");
printf("\nIngrese numero de cliente: ");
scanf("%d",&ped.nCliente);
while(ped.nCliente!=0)
{
printf("Ingrese codigo de producto: ");
scanf("%d",&ped.cod);
printf("Ingrese cantidad pedida: ");
scanf("%d",&ped.cant);
acolar(&cola,&ped);
printf("\nIngrese numero de cliente: ");
scanf("%d",&ped.nCliente);
}
while(desacolar(&cola,&ped))
{
printf("\nCliente: %d\nProducto: %d\nCantidad: %d unidades\n",ped.nCliente,ped.cod,ped.cant);
fseek(pf,0,0);
fread(&prod,sizeof(t_producto),1,pf);
while(!feof(pf))
{
if(ped.cod==prod.codPr)
{
if((prod.cantStock-ped.cant)>=prod.minStock)
{
printf("\nPedido del cliente %d.Fue realizado exitosamente.\n",ped.nCliente);
prod.cantStock-=ped.cant;
fseek(pf,-sizeof(t_producto),1);
fwrite(&prod,sizeof(t_producto),1,pf);
fseek(pf,0,1);
}
else
{
if((prod.cantStock-ped.cant)>=0)
{
printf("\nPedido del cliente %d.Fue realizado, stock por debajo del minimo necesario.\n",ped.nCliente);
prod.cantStock-=ped.cant;
fseek(pf,-sizeof(t_producto),1);
fwrite(&prod,sizeof(t_producto),1,pf);
fseek(pf,0,1);
apilar(&pila,&prod);
}
else
{
printf("\nPedido del cliente %d.No tenemos el suficiente stock para afrontar la venta.\n",ped.nCliente);
ponerEnLista(&lista,&ped);
}
}
}
fread(&prod,sizeof(t_producto),1,pf);
}
}
printf("\nARCHIVO ACTUALIZADO\n");
fseek(pf,0,0);
mostrarArchivo(pf);
fclose(pf);
}
int main(int argc, char** argv) {
char input[INPUTSIZE];
while(fgets(input , INPUTSIZE , stdin) != NULL)
{
switch(input[0]){
case 'p':
primerAlumno();
break;
case 'u':
ultimoAlumno();
break;
case 'i':
{
char * id, *nom, *tel;
strtok(input,",");
id = strtok(NULL, ",\n\t");
nom = strtok(NULL, ",\n\t");
tel = strtok(NULL, ",\n\t");
insertarAlumno(atoi(id),nom,atoi(tel));
break;
}
case 'b':
{
char* id;
strtok(input,",\n\t");
id = strtok(NULL, ",\n\t");
if (input[1] == 'u'){
//buscar
buscarAlumno(atoi(id));
break;
}else{
//borrar
borrarAlumno(atoi(id));
break;
}
}
case 'c':
crearLista();
break;
case 'l':
{
if(input[5] == 'r'){
listarAlumnos();
break;
}else{
listaVacia();
break;
}
}
case 'm':
{
char * id, *tel;
strtok(input,",\n\t");
id = strtok(NULL, ",\n\t");
tel = strtok(NULL, ",\n\t");
modificarTelefono(atoi(id),atoi(tel));
break;
}
}
}
while( alumnos.primero != NULL ){
struct nodo *ptr;
ptr = alumnos.primero;
alumnos.primero = ptr->sig;
free(ptr);
}
/*
crearLista();
insertarAlumno(172799,"Arnau",685412152);
insertarAlumno(175214,"PEPA",52341451);
insertarAlumno(174521,"JOAQUIN",54548215);
insertarAlumno(184521,"f1",9685485);
insertarAlumno(114521,"g3",15641655);
listarAlumnos();
ultimoAlumno();
borrarAlumno(184521);
ultimoAlumno();
primerAlumno();
borrarAlumno(172799);
buscarAlumno(174521);
buscarAlumno(172799);
primerAlumno();
listarAlumnos();*/
//HACER FREEEEE DE LA COLA ENTERA ********************************************************************************
#if DEBBUGPRIMERO
primerAlumno();
borrarAlumno(114521);
primerAlumno();
#endif
#if DEBBUGBORRAR
borrarAlumno(3652); //comprobamos que si no existe el nia no borra nada
borrarAlumno(175214);
listarAlumnos();
#endif
#if DEBBUGULTIMO
ultimoAlumno();
borrarAlumno(184521);
ultimoAlumno();
#endif
#if DEBBUGTELEFONO
modificarTelefono(174521);
listarAlumnos();
#endif
return (EXIT_SUCCESS);
}
nodo *infijaPosfija(char expresion[])
{
nodo *pila,*posfija;
int longitudExpresion, i;
char valor;
pila = crearLista(pila); //inicilar la pila con la funcion//
posfija = crearLista(posfija); // inicializar
longitudExpresion = strlen(expresion); // se necesita para ir recorriendo la lista 1 en 1 (longitud);
for(i = 0; i<longitudExpresion; i++)
{
if (((expresion[i]>=48) && (expresion[i]<=57)) ||((expresion[i]>=65) && (expresion[i]<=90)) || ((expresion[i]>=97) && (expresion[i]<=122)))
posfija =insertarNodoFinal(expresion[i],posfija);
else
{
if (expresion[i]== '(')
pila = push(expresion[i], pila);
else
{
if(esOperador(expresion[i]))
{
if(pila == NULL)
pila = push(expresion[i],pila);
else
{
while(pila!=NULL)
{
if((prioridad (pila->simbolo)>= prioridad(expresion[i])))
{
pila =pop(&valor, pila);
posfija = insertarNodoFinal(valor, posfija);
}
else
break;
}
pila = push(expresion[i],pila);
}
}
}
}
if(expresion[i]== ')')
{
while((pila->simbolo!= '(') &&(pila!=NULL))
{
pila= pop(&valor,pila);
posfija = insertarNodoFinal(valor,posfija);
}
pila =pop(&valor,pila);
}
}
while(pila!=NULL)
{
pila =pop(&valor, pila);
posfija=insertarNodoFinal(valor,posfija);
}
return posfija;
}
