bool lista::borrar_Noticia (Tcadena1 cad){
char cad2[MaxCadRef];
poner_fin();
while(!inicio()){
retroceder();
if(elemento[pi].Vacia()) return false;
TipoDato dat;
elemento[pi].Poner_Inicio();
while(elemento[pi].Fin()==false){
elemento[pi].Consultar(dat);
if(dat.Comparar(cad)==0){;
elemento[pi].Borrar();
return true;}
elemento[pi].Avanzar();
}
}
return false;
}
// Soluciona la mazmorra
int solucion(void) {
int i;
paso_t * L = NULL;
paso_t * p = NULL;
// Agrego paso inicial, ingresando al laberinto hacia el norte
p = nodo();
cerrar(p, 'S');
avanzar(&L,p);
// Ciclo hasta salir del laberinto
do {
usleep(PAUSA);
if(L==NULL) {
printf("Volvimos a la entrada, el laberinto no tiene salida!\n");
exit(1);
}
if(L->N == ABIERTO) {
i=intentar(&L,'N');
}
else if (L->S == ABIERTO) {
i=intentar(&L,'S');
}
else if (L->O == ABIERTO) {
i=intentar(&L, 'O');
}
else if (L->E == ABIERTO) {
i=intentar(&L, 'E');
}
else {
printf("No se puede avanzar, retrocediendo un paso...\n");
retroceder(&L);
}
} while (i!=SALIDA);
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;
}
int bt(int ** tablero, int dimension, int filini, int colini,
int * peso_solucion, par * soa)
{
/* primero todas las variables que necesitamos!!!!!!!!!!
* PXS
* sandrita, se me va la cabeza :$ por ti! */
/* como la solucion final estara en soa, en vez de considerar
* el parametro de la funcion como s, lo consideramos como soa */
par * s;
int ** recorridos;
par * paresmov;
int voa;
int peso;
int nivel;
int * mov;
int i;
/* procedemos a inicilizar todas las variables que hemos declarado */
/* memoria para s y soa */
s = (par *)malloc(MAXNIVEL*sizeof(par));
/* vamos a inicializar estas dos variables anterios, cada par tendra
* el valor de (-1,-1) */
inicializa_pares(s, -1, dimension);
inicializa_pares(soa, -1, dimension);
/* y la de movimientos! que son inicializados a -1 */
mov = (int *)malloc(MAXNIVEL*sizeof(int));
for (i = 0; i < MAXNIVEL; i++) {
mov[i] = -1;
}
/* creamos el array que tiene codificados los 4 movimientos */
paresmov = (par *)malloc(3*sizeof(par));
inicializa_paresmov(paresmov);
/* tambien inicializamos recorridos */
recorridos = inicializa_matriz(dimension, 0);
/* inicializacion de las variables! */
voa = 0xffff;
recorridos[filini][colini] = 1;
s[0].f = filini;
s[0].c = colini;
nivel = 0;
/* peso almacena el peso del camino que vamos a formar */
peso = tablero[s[0].f][s[0].c];
/* el cuerpo de nuestro programa */
do {
/*pinta_s(s, dimension);*/
if (solucion_bt(s, nivel, dimension)) {
if (peso < voa) {
voa = peso;
/*printf("Nueva solucion optima\n");
pinta_s(s, dimension);*/
asigna_pares(s, soa);
}
}
if (criterio(recorridos, s, peso, voa, nivel, dimension)) {
nivel++;
generar(tablero, mov, recorridos, s, nivel, &peso, paresmov);
}
else {
while ((nivel != 0) && (!mashermanos(mov, nivel))) {
retroceder(tablero, recorridos, mov, s, &nivel, &peso);
}
if (nivel != 0) {
generar(tablero,mov,recorridos,s,nivel,&peso,paresmov);
}
}
} while (nivel != 0);
*peso_solucion = voa;
return 0;
}
