int main() {
List lista;
BSTree pasados[ HASHSIZE ];
lista = NULL;
int x;
for(x=0; x<HASHSIZE; x++) {
pasados[x] = NULL;
}
printf("Ingrese una lista de enteros separados por coma:");
char str[2000] = "";
scanf("%s", str);
lista = crear_lista(lista, str);
printf("La lista es: \n");
mostrar_lista(lista);
printf("\n\n");
List rList = lista;
printf("\n\nSacando Duplicados Queda: ");
sacar_duplicados(lista, pasados);
mostrar_lista(lista);
printf("\n\n");
}
void crear_sala(char *sala_agregar, usuario *user) {
pthread_mutex_lock(&mutex_salas);
if (existe_elemento(lista_global_salas, sala_agregar, salas_iguales)) {
pthread_mutex_lock(&user->mutex_socket);
write(user->socket, "\nLa sala ya existe.\n\n", 21);
pthread_mutex_unlock(&user->mutex_socket);
pthread_mutex_unlock(&mutex_salas);
return;
}
sala *nueva_sala = malloc(sizeof(sala));
if (nueva_sala == NULL) {
fprintf(stderr, "No se puede asignar memoria.\n");
pthread_mutex_unlock(&mutex_salas);
return;
}
nueva_sala->nombre_sala = sala_agregar;
crear_lista(&nueva_sala->lista_usuarios_activos);
agregar_principio(&lista_global_salas, nueva_sala);
pthread_mutex_unlock(&mutex_salas);
}
int main(void){
T_LISTA mi_lista;
mi_lista=crear_lista();
mostrar_lista(mi_lista);
printf("\n\n---------------------\n\n");
ordena_lista(&mi_lista);
mostrar_lista(mi_lista);
return 0;
}
/*
Lee una lista de info_t desde la entrada estándar. Después de cada elemento
hay un espacio en blanco. Termina con un punto.
*/
lista leer_lista() {
lista res = crear_lista();
info_t info = leer_info(MAX_LARGO_PALABRA);
while (es_valida_info(info)) {
insertar_despues(info, final_lista(res), res);
info = leer_info(MAX_LARGO_PALABRA);
}
liberar_info(info);
return res;
} // leer_lista
bool crear_recorrido(recorrido_t *recorrido, const char *nombre_archivo,
grafo_t *grafo){
strncpy(recorrido->nombre_archivo, nombre_archivo, MAX_CARACTERES_ARCHIVO);
recorrido->nombre_archivo[MAX_CARACTERES_ARCHIVO - 1] = '\0';
recorrido->distancia_total = 0;
recorrido->grafo = grafo;
crear_lista(&(recorrido->lista), "Recorrido");
bool ok = leer_archivo(recorrido);
computar_distancias(recorrido);
return ok;
}
int main(){
t_lista pl;
t_info pd;
puts("CREANDO LISTA... \n");
crear_lista(&pl);
pd.num = 4;
printf("INSERTANDO %d ... \n",pd.num);
//insertarEnOrden(&pl, &pd, comparar);
insertarAdelante(&pl, &pd);
//insertarAlFinal(&pl, &pd);
pd.num = 1;
printf("INSERTANDO %d ... \n",pd.num);
//insertarEnOrden(&pl, &pd, comparar);
//insertarAdelante(&pl, &pd);
insertarAlFinal(&pl, &pd);
pd.num = 2;
printf("INSERTANDO %d ... \n",pd.num);
//insertarEnOrden(&pl, &pd, comparar);
insertarAdelante(&pl, &pd);
//insertarAlFinal(&pl, &pd);
printf("\nLISTA VACIA?: %s\n", listaVacia(&pl)==1?"SI":"NO");
puts("LISTANDO... \n");
listar(&pl);
ordenar(&pl, comparar);
puts("LISTANDO... \n");
listar(&pl);
puts("\nELIMINANDO EL 4... \n");
pd.num = 4;
eliminarDeListaNoOrdenada(&pl, &pd, comparar);
puts("LISTANDO... \n");
listar(&pl);
return 0;
}
int main(int argc, char **argv)
{
FORTRAN_file_descriptor f_dcd=55;
int natoms, nframes;
int stride=1000; /*para saltear pasos*/
COORD *coord;
LIST_ID *oxidrilos;
int i,j;
oxidrilos = crear_lista(10);
i_lee_dcd_ (&f_dcd, &natoms, &nframes);
coord = My_malloc((size_t) natoms * 3 * sizeof(COORD));
fprintf(stderr, "nframes %d,\tnatoms %d\n", nframes, natoms);
for(j=0; j<nframes; j+=stride)
{
fprintf(stderr, "\nLeyendo foto %d\n", j);
lee_dcd_ (&f_dcd, &natoms, coord);
for(i = 0; i<natoms; i++)
{
printf( "coord mol %d : %f, %f, %f \n" ,
i, coord[i].x, coord[i].y, coord[i].z);
}
}
c_lee_dcd_ (&f_dcd);
My_free(coord);
eliminar_lista(oxidrilos);
return(0);
}
void desuscribir_usuario(usuario *user) {
pthread_mutex_lock(&mutex_salas);
nodo *aux;
sala *s;
aux = user->lista_salas_suscritas.cabeza;
while (aux != NULL) {
s = (sala *) aux->elemento;
eliminar_elemento(&s->lista_usuarios_activos, user->nombre_usuario,
usuarios_iguales, 0);
aux = aux -> sig;
}
crear_lista(&user->lista_salas_suscritas);
pthread_mutex_unlock(&mutex_salas);
}
int main(void) {
configurar();
conectar_maestroCPU();
logueo();
inicializar_semaforos();
crear_lista();
//Este hilo va a escuchar y aceptar las conexiones, con las CPU de forma paralela a la ejecucion de este proceso "main"
pthread_create(&ejecucion, NULL, ejecutar_proceso, NULL);
pthread_create(&recibir, NULL, recibir_cpu, NULL);
pthread_create(&bloquear, NULL, bloquear_procesos, NULL);
menu();
liberar_memoria();
printf(BLANCO "Procesos " ROJO "Finalizados " AZUL "=)\n" FINDETEXTO);
return 0;
}
int main() {
lista lst = crear_lista();
nat cont_comandos = 0;
bool salir = false;
while (!salir) {
mostrar_prompt(cont_comandos);
enum_cmd_t enum_com = identificador_comando();
// procesar el comando
switch (enum_com) {
case cmd_fin:
salir = true;
imprimir_con_nl(msg_fin);
break;
case cmd_comentario:
escribir_nueva_linea();
break;
case cmd_ins_lista: {
info_t info = leer_info(MAX_LARGO_PALABRA);
while (es_valida_info(info)) {
insertar_despues(info, final_lista(lst), lst);
info = leer_info(MAX_LARGO_PALABRA);
}
liberar_info(info);
texto_t txt = cadena_a_texto("primero");
info = crear_info(0, txt);
insertar_antes(info, inicio_lista(lst), lst);
imprimir_lista(lst);
break;
}
case cmd_recorrido_lista: {
if (!es_vacia_lista(lst)) {
localizador loc = inicio_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = siguiente(loc, lst);
}
loc = final_lista(lst);
while (es_localizador_lista(loc)) {
texto_t txt = info_a_texto(info_lista(loc, lst));
escribir_texto(txt);
liberar_texto(txt);
loc = anterior(loc, lst);
}
escribir_nueva_linea();
}
break;
}
case cmd_segmentos_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador desde = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador hasta = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(desde) && es_localizador_lista(hasta) &&
precede_en_lista(desde, hasta, lst)) {
lista sgm = separar_segmento(desde, hasta, lst);
lista copia = segmento_lista(inicio_lista(sgm), final_lista(sgm), sgm);
imprimir_lista(sgm);
liberar_lista(sgm);
insertar_segmento_despues(copia, final_lista(lst), lst);
liberar_lista(copia);
imprimir_lista(lst);
}
break;
}
case cmd_modificar_lista: {
int clave1 = leer_int();
int clave2 = leer_int();
localizador loc1 = siguiente_clave(clave1, inicio_lista(lst), lst);
localizador loc2 = anterior_clave(clave2, final_lista(lst), lst);
if (es_localizador_lista(loc1) && es_localizador_lista(loc2)) {
intercambiar(loc1, loc2, lst);
imprimir_lista(lst);
retroceder(loc2, lst);
imprimir_lista(lst);
}
break;
}
case cmd_ordenar_lista: {
nat len_lst = longitud(lst);
imprimir_int(len_lst);
localizador loc = inicio_lista(lst);
for (nat i = 0; i < len_lst / 2 - 1; i++)
loc = siguiente(loc, lst);
lista primera = segmento_lista(inicio_lista(lst), loc, lst);
lista segunda =
segmento_lista(siguiente(loc, lst), final_lista(lst), lst);
lista concat = concatenar(primera, segunda);
imprimir_lista(concat);
liberar_lista(concat);
if (son_numeros_iguales(primera, segunda)) {
imprimir_lista(primera);
}
if (!esta_ordenada(primera))
ordenar(primera);
if (!esta_ordenada(segunda))
ordenar(segunda);
lista mzc = mezcla(primera, segunda);
imprimir_lista(mzc);
unificar(mzc);
imprimir_lista(mzc);
liberar_lista(mzc);
liberar_lista(primera);
liberar_lista(segunda);
break;
}
case cmd_filtrado_lista: {
int clave = leer_int();
texto_t palabra = leer_palabra(MAX_LARGO_PALABRA);
comp_t criterio = texto_a_comp(palabra);
liberar_texto(palabra);
if (pertenece(clave, lst)) {
imprimir_int(cantidad(clave, lst));
}
lista flt = filtrado(clave, criterio, lst);
imprimir_lista(flt);
liberar_lista(flt);
break;
}
case cmd_reversa_lista: {
int dato1 = leer_int();
int dato2 = leer_int();
if (esta_ordenada(lst) && pertenece(dato1, lst) &&
pertenece(dato2, lst) && dato1 < dato2) {
lista sub = sublista(dato1, dato2, lst);
imprimir_lista(sub);
lista rev = reversa(sub);
imprimir_lista(rev);
cambiar_todos(dato1, dato2, rev);
imprimir_lista(rev);
liberar_lista(sub);
liberar_lista(rev);
}
break;
}
case cmd_liberar_lista: {
liberar_lista(lst);
lst = crear_lista();
break;
}
default:
imprimir_con_nl(msg_cmd_no_reconocido);
break;
} // switch
texto_t resto_linea = leer_resto_linea(MAX_RESTO_LINEA);
liberar_texto(resto_linea);
} // while
liberar_lista(lst);
return 0;
}