NODO *regla2b(NODO * nodoActual, int g, int j, int i, int *e, char *S){ int *nuevo_to; NODO *nuevo1; // Es el que parte la arista NODO *nuevo2; // Es la nueva hoja char* Saux; nuevo_to = (int *) malloc(sizeof(int)); if(nodoActual->posS1!=0) Saux=S1; else Saux = S2; //Nodo que parte la arista *nuevo_to = nodoActual->from + g - 1; nuevo1 = crearNodo(0, nodoActual->padre, NULL, nodoActual->from, nuevo_to, Saux); //Actualizamos nodoActual nodoActual->padre = nuevo1; nodoActual->from = *nuevo_to + 1; nuevo1->hijos[s_i(Saux, nodoActual->from)] = nodoActual; // le asigno el hijo al nuevo1 //Nodo que contiene a S[i+1] nuevo2 = crearNodo(0, nuevo1, NULL, i + 1, e, S); //cuando digo que nuevo1 lo tiene a nuevo2 de hijo?????? extension_regla2b(nuevo1, nuevo2, j, nodoActual->posS1, nodoActual->posS2); return nuevo2; }
/** * * Funcion que corrige el arbol una vez creado, revisa si cada Funcion tiene * su sus argumentos respectivos, si le falta le agrega uno deterministicamente * **/ void rebuilt(Arbol *a) { if(a != NULL) { if(funciones[a->valor] == 1) { if(a->izq == NULL) { Arbol *aux; int setear = abs((a->id % 16) - (a->valor % 16)) + 16; aux = crearNodo(((setear < 32) ? setear: 16), contador++); if(a->izq == NULL) a->izq = aux; else a->der = aux; } } if(funciones[a->valor] == 2) { if(a->izq == NULL) { Arbol *aux; int setear = abs((a->id % 16) - (a->valor % 16)) + 16; aux = crearNodo(((setear < 32) ? setear: 16), contador++); a->izq = aux; } if(a->der == NULL) { /* gramatica */ Arbol *aux; int setear, valor; /* Si el padre es un Funcion de Coloracion el lado derecho tiene que ser un terminal*/ if(a->valor < 7) { setear = abs((a->id % 16) - (a->valor % 16) + 16); valor = (setear < 32) ? setear: 16; } /* Si el padre es un Funcion Generica el lado derecho tiene que ser una funcion de coloracion */ else { setear = abs((a->id % 5) - (a->valor % 5)); valor = (setear < 5) ? setear: 4; } aux = crearNodo(valor, contador++); a->der = aux; } } rebuilt(a->izq); rebuilt(a->der); } }
int cargarArbolHuffman(struct nodo **raiz, BYTE *mem) { struct nodo *aux, *nuevo; int pos_mem=0, pos_pos=0, dch=0; BYTE b; *raiz=crearNodo(); readBits(mem, &pos_mem, &pos_pos, &b, 1); if (b == UNO) { readBits(mem, &pos_mem, &pos_pos, &b, 8); (*raiz)->c=b; return 2; } aux=*raiz; while (aux != NULL) { nuevo=crearNodo(); nuevo->padre=aux; readBits(mem, &pos_mem, &pos_pos, &b, 1); if (b == 0) { if (dch) { aux->hdch=nuevo; dch=0; } else aux->hizq=nuevo; aux=nuevo; } else { readBits(mem, &pos_mem, &pos_pos, &b, 8); nuevo->c=b; if (dch) { aux->hdch=nuevo; aux=buscarNodoSinHdch(aux); } else { aux->hizq=nuevo; dch=1; } } } return pos_mem+1; }
NODO *regla2a(NODO * nodoActual, int j, int i, int *e, char *S) { NODO *nuevo; nuevo = crearNodo(0, nodoActual, NULL, i + 1, e, S); extension_regla2a(nuevo, j); // para los arboles generalizados return nuevo; }
/*Agrega un elemento en la posicion correspondiente a su prioridad. * cp: cola de prioridades a agregarle el elemento nuevo. * info: informacion a agregar en la cola de prioridades. * prior: prioridad de la informacion a agregar. */ void agregarElemP(ColaP* cp, char* info, int prior){ Nodo* np = crearNodo(info,prior); if (cp->tam == 0){ cp->pri = np; cp->tam = 1; return; } Nodo* aux = cp->pri; int i = 0; for (i = 0; i < cp->tam && aux->prior < prior; i++) aux = aux->sig; if (aux == NULL){ aux = cp->pri; for (i=0; i < cp->tam && aux->sig != NULL; i++) aux = aux->sig; aux->sig = np; np->ant = aux; cp->tam += 1; return; } if (aux->ant == NULL){ cp->pri = np; } else { aux->ant->sig = np; } np->sig = aux; np->ant = aux->ant; aux->ant = np; cp->tam += 1; }
void *atenderANodo(void *argConexion) { SocketConecta *conexion = argConexion; while(estaConectado(conexion)) { char nombrePaquete; t_nodo *nodo; recibirMensaje(conexion, &nombrePaquete,1); if(estaConectado(conexion)) { if (nombrePaquete == CANTIDAD_BLOQUES) nodo = crearNodo(conexion); else if (nombrePaquete == BLOQUEAR_ATENDER_NODO){ reservarConexionNodo(nodo); devolverConexionNodo(nodo); } }else { deshabilitarNodoPorDesconexion(nodo); loguear(LOG_LEVEL_INFO,"Se desconecto el nodo %s\n",nodo->nombre); cerrarSocketConecta(conexion); } } return 0; }
void capturaPolinomio( POLINOMIO *ptrPolinomio ) { POLINOMIO ptrNuevo = NULL; int coef, exp, nM , opc = 1; nM = 0; printf( "\n Introduzca los miembros del polinomio \n "); do { printf( "\n Miembro %d \n\n", nM += 1 ); printf( " Coeficiente = " ); scanf( "%d", &coef ); printf( " Exponente de x = " ); scanf( "%d", &exp ); if( crearNodo( &ptrNuevo , coef, exp ) ) { ptrNuevo -> ptrLiga = *ptrPolinomio; *ptrPolinomio = ptrNuevo; }else { printf( " Error se ha desbordado la memoria \n\n "); break; } printf("\n Otro miembro ? ( 1:Si - 0:No ) " ); scanf( "%d", &opc ); }while( opc ); }
int main(int argc, char **argv) { Nodo *head; head = NULL; head = crearNodo(12,"gustavo",head); head = crearNodo(14,"maria",head); head = crearNodo(16,"pedro",head); head = crearNodo(15,"gabriel",head); //recorrer pila Nodo* ptr; ptr = head; while (ptr != NULL){ printf("sd:[%d] nombre:[%s] \n", ptr->sd, ptr->nombre); ptr = ptr->siguiente; } return 0; }
/** * * Funcion que construye desde un string de enteros, el arbol, usa notacion * preorden(prefija), osea de izq a der. * **/ void construir(Arbol **raiz, int valor, int i, int padre, int lado) { /* printf("inicioConst\n"); */ if((*raiz) == NULL && bandera == 0) { /* Gramatica */ /* Si el padre es una funcion de coloracion su hijo debe ser un terminal */ if(padre < 7 && valor < 16) { int setear = abs((i % 16) - (valor % 16)) + 16; valor = (setear < 32) ? setear: 16; } /* Si el padre es una funcion generica su hijo derecho debe ser una funcion generica o funcion de coloracion */ else if(padre > 6 && padre < 16 && lado == 1 && valor > 15) { int setear = abs((i % 16) - (valor % 16)); valor = (setear < 16) ? setear: 0; } *raiz = crearNodo(valor, i); bandera = 1; } else if((*raiz) != NULL) { if((*raiz)->valor > 15) { /* printf("\tterminal-\n"); */ } else { /* printf("\tfuncion-\n"); */ if(funciones[(*raiz)->valor] == 1) { /* printf("\tizq arg1\n"); */ construir(&((*raiz)->izq), valor, i, (*raiz)->valor, 0); } else if(funciones[(*raiz)->valor] == 2) { /* printf("\tizq arg2"); */ construir(&((*raiz)->izq), valor, i, (*raiz)->valor, 0); /* printf("\tder arg2"); */ construir(&((*raiz)->der), valor, i, (*raiz)->valor, 1); } } } /* printf("FinConst\n"); */ }
Huffman::Huffman() { this->sz = 0; this->buffer.bitsOcupados = 0; this->buffer.buffer = 0; this->caracterNuevo = true; this->termino = false; this->buscarPosicion = false; this->codigo = new Cola(); this->cantidadAimprimir = 1; this->i = 1; for (int i = 0; i < MAX; i++) { inicialCompleto[i] = crearNodo(i, 1); a[i] = inicialCompleto[i]; // Asigno al vector "a" todo el vector inicialCompleto } }
struct nodo *insertar(struct nodo *raiz, BYTE c) /* * Inserta al principio de la lista enlazada un nuevo * nodo con el caracter `c' */ { struct nodo *tmp=raiz; raiz=crearNodo(); raiz->c=c; raiz->freq=1; raiz->sig=tmp; return raiz; }
int main(int argc, char **argv) { printf("Ejercicio TicTacToe.\n"); int jugador; //+1 o -1 int primero,ganador; tNodo *juego = crearNodo(tablero_inicial); dispNodo(juego); printf("El Agente Inteligente juega con X \n El Jugador Humano con O \n Elige el turno 1:Primero o 2:Segundo "); scanf("%d",&primero); printf("\n"); if(primero == 1) jugador = -1; //Turno de Min else jugador = 1; //Turno de Max ganador = terminal(juego,jugador); while(juego->vacias > 0 && ganador == 0) { if(jugador == 1) juego = (tNodo *) PSEUDOminimax(juego); else juego = (tNodo *) jugadaAdversario(juego); dispNodo(juego); ganador = terminal(juego,jugador); jugador = opuesto(jugador);//turno del adversario } switch(ganador) { case 100: printf("\n HE GANADOOOO\n"); break; case 0: printf("\n EMPATE\n"); break; case -100: printf("\n Increible pero has ganado tu :(( \n\n"); break; default: printf("\n algo ha salido mal en el juego ..\n"); } return 0; }
Nodo* CrearLista(int enteros[], int tamanio) { if(tamanio != 0){ nodo *lista, *aux, *nuevoNodo; tamanio =-tamanio; crearNodo(&lista, enterios[tamanio]); aux = lista; for(int i = tamanio-j;i>=0; i--){ CrearNodo(&nuevoNodo, enteros[i]); aux->anterior = nuevoNodo; nuevoNodo->siguiente = aux; aux = nuevoNodo; } return lista; } return null; }
struct nodo *crearArbolHuffman(struct nodo *raiz) { struct nodo *nuevo; if (raiz == NULL) return NULL; while (raiz->sig != NULL) { nuevo=crearNodo(); nuevo->freq=raiz->freq + raiz->sig->freq; nuevo->hizq=raiz; nuevo->hdch=raiz->sig; raiz=insertarOrden(raiz->sig->sig, nuevo); } return raiz; }
void Huffman::crearArbol(Nodo* nodoActual[], int numeroMaximo) { bool yaEncontrePosicion; int u = 0, posicionInsercion, frecuencia; Nodo* ptr; ordenarNodos(nodoActual, numeroMaximo); for (int n = numeroMaximo; n > 1; n--) { //ordenarNodos(nodoActual,n); u = nodoActual[0]->getFrecuencia() + nodoActual[1]->getFrecuencia(); str = nodoActual[0]->getNumero() + nodoActual[1]->getNumero(); ptr = crearNodo(str, u); ptr->setHijoDerecho(nodoActual[1]); ptr->setHijoIzquierdo(nodoActual[0]); nodoActual[0] = ptr; yaEncontrePosicion = false; posicionInsercion = n - 2; frecuencia = nodoActual[0]->getFrecuencia(); for (int i = 1; i < n - 1; i++) { if (!yaEncontrePosicion && nodoActual[i]->getFrecuencia() > frecuencia) { posicionInsercion = i - 2; yaEncontrePosicion = true; } nodoActual[i] = nodoActual[i + 1]; } for (int j = 0; j < posicionInsercion; j++) { nodoActual[j] = nodoActual[j + 1]; } nodoActual[posicionInsercion] = ptr; } }
/** * * Funcion que que convierte el cromosma binario en un Arbol, esta funcion es * llamada por la funcionObjetivo del AG * **/ void convertion(bool *chrm, bool grafica) { Arbol *A, *izq, *aux, *aux2; int i, nChrm, h, hmax, setear, nuevo_valor, *array;/* [8] = {6, 0, 16, 7, 1, 18, 4, 21}; */ bool lado = 0; FILE *filetree; char *str; char nombres[][35] = { /* Funciones de Coloracion */ "Greedy Coloring", "ColoringMoreFrequentColor", "ColoringLessFrequentColor", "UnColoring", "ColoringNeighbors", "InterchangeColor", "UncoloringNeighbors", /* Funciones que se repiten - solo de coloracion */ "EqualX", "IfX", "AndX", /* Funciones Genericas */ "While", "If", "And", "Equal", "Or", "Not", /* Terminales */ "vertexLargestDegree","vertexMinimumDegree", "firstVertex", "vertexLowestNumberedColor", "vertexHighestNumberedColor", "vertexMoreFrequentColor", "vertexLessFrequentColor", "vertexSaturationDegree", "vertexMoreUncoloredNeighbors", "vertexIncidenceDegree", "not_Increase?", "ExistUncoloredVertex?", /* Terminales que se repiten */ "vertexLowestNumberedColor", "vertexHighestNumberedColor", "vertexMoreFrequentColor", "vertexLessFrequentColor"}; A = NULL; nChrm = sizeChrm / nByte; contador = nChrm; bandera = 0; h = 0; hmax = 12; array = calloc(nChrm, sizeof(int)); getChrm(chrm, array); for(i=0; i<5; i++) funciones[i] = 1; for(i=5; i<16; i++) funciones[i] = 2; funciones[15] = 1; funciones[6] = 1; for(bandera=0, i=0; i<nChrm; i++) { /* /\* Si el primer elemento es un Terminal se cambia por una Funcion *\/ */ /* if(i == 0 && array[i] > 15) */ /* { */ /* setear = abs((0 % 16) - (array[i] % 16)); */ /* array[0] = (setear < 16) ? setear: 0; */ /* } */ /* /\* Si el ultimo elemento es una Funcion se cambia por un Terminal *\/ */ /* if(i == (nChrm - 1) && array[(nChrm - 1)] < 16) */ /* array[nChrm - 1] = array[nChrm - 1] + 16; */ construir(&A, array[i], i, -1, -1); if(bandera == 0) { /* Guardamos el arbol en otro arbol auxiliar */ aux = A; /* Creamos un segundo Arbol auxiliar con los datos del nodo que correspondia */ aux2 = crearNodo(array[i], i); /* El arbol original lo setiamos y creamos un nodo con una Funcion, que sea siempre con dos argumentos, una funcion generica*/ setear = abs((A->id % 16) - (A->valor % 16)); nuevo_valor = ((setear < 15) ? setear: 14); if(funciones[nuevo_valor] == 1) nuevo_valor = nuevo_valor + 10; if(nuevo_valor == 5 || nuevo_valor == 6) { nuevo_valor = nuevo_valor + 8; } A = crearNodo(nuevo_valor, contador++); /* El nuevo nodo tiene de hijo a la izq al primer auxiliar y el der. al segundo auxiliar si LADO es 0 si es 1 viceversa. Se van rotando para que los arboles no sean tan desbalanciados*/ if(lado == 0) { A->izq = aux; A->der = aux2; lado = 1; } else { A->izq = aux2; A->der = aux; lado = 0; } } bandera = 0; /* printf("Fin Costruir\n\n"); */ } /* Liberar el arreglo con las F y T */ /* free(array); */ rebuilt(A); /* salidaNameArbol(A); */ if(grafica) { i = snprintf(NULL, NULL, "%s/Arbol.dot", ruta_resultados); str = malloc((i+1) *sizeof(char)); snprintf(str, i+1, "%s/Arbol.dot", ruta_resultados); filetree = fopen(str, "w"); free(str); fprintf(filetree, "digraph G{\n"); fprintf(filetree, "%d [ label = \"%s\" ];\n", A->id, nombres[A->valor]); izq = A->izq; fprintf(filetree, "%d [ label = \"%s\" ];\n", izq->id, nombres[izq->valor]); imprimir(A, filetree, nombres); fprintf(filetree, "}"); fclose(filetree); i = snprintf(NULL, NULL, "dot %s/Arbol.dot -o %s/arbol.png -Tpng", ruta_resultados, ruta_resultados); str = malloc((i+1) *sizeof(char)); snprintf(str, i+1, "dot %s/Arbol.dot -o %s/arbol.png -Tpng", ruta_resultados, ruta_resultados); printf("%s\n",str); if(system(str)) printf("No se pudo dibujar el Arbol\n"); free(str); } conexion(A, grafica); freeArbol(A); free(array); }
NODO *ukkonen(NODO* I, char *S, int m, int* e){ int root_to; int matcheado=0; int i, j_i, j_estrella; // i = fases j = extensiones int regla3 = 0; int reglaAnterior = 0; int faseInicial; int auxg=0; // estas variables se utilizan para hacer reglas 3 en el caso especial int k, p1, p2; NODO* auxiliar; // int auxj_i=0; NODO* nodoAnterior; if(flagString == 1){ faseInicial = 1; *e = 0; root_to = 0; j_i = 1; /*------------Genero I(1)------------*/ // Crear el root I = crearNodo(0, NULL, NULL, 0, &root_to, S); //Creamos el hijo *e = *e + 1; nodoAnterior = crearNodo(0, I, NULL, 1, e, S); nodoAnterior->posS1=1; } else{ special_find(ST, &auxg, &matcheado); // printf("auxg: %d n->S1: %d n->S2: %d e: %d\n", auxg, nodoAnterior->posS1, nodoAnterior->posS2, matcheado); // printTotalString(nodoAnterior); //printSTree(ST,1); if(matcheado>=2){ p2=matcheado-1; for(k=2;k<=matcheado;k++){ p1=p2; auxiliar=find_j_i_naive(ST, &p1, k, S2, 1); calculaRegla(auxiliar, p1, k, i, S2); p2--; } } //printSTree(ST,1); *e = matcheado; faseInicial = matcheado; nodoAnterior=ST; // inicialmente empieza desde la raiz j_i = 0; } /*-----------Calculo I(i+1)-----------*/ for (i = faseInicial; i <= (m - 1); i++) { //Comienza Fase i+1 /*----SPA---- */ //ver pag 106 Dan Gusfuield // paso 1 regla1(e); reglaAnterior = 1; // paso 2 while ((i + 1 > j_i) && (!regla3)){//mientras(no regla3 o hicimos todas las extnsiones nodoAnterior = SEA(I, nodoAnterior, j_i + 1, i, ®la3, ®laAnterior, e, S); j_i++; /* if(reglaAnterior==3 && flagString==2 && auxj_i==0){ auxj_i=j_i; }*/ //printSTree(I, 1); } /* if(auxj_i!=0 && flagString == 2){ //restauro el valor de j_i pues hice muchas veces regla 3 j_i=auxj_i; auxj_i=0; } */ if (regla3) { j_estrella = j_i; regla3 = 0; } else j_estrella = i + 2; //paso 3 j_i = j_estrella - 1; if(i==faseInicial) flagSpecial = 0; } return (I); }