Arrays y estructuras

5.1. Conceptos bsicos sobre tablas

5.1.1. Definicin de una tabla y acceso a los datos Una tabla, vector, matriz o array (que algunos autores traducen por arreglo) es un conjunto de elementos, todos los cuales son del mismo tipo. Estos elementos tendrn todos el mismo nombre, y ocuparn un espacio contiguo en la memoria. Por ejemplo, si queremos definir un grupo de 4 nmeros enteros, usaramos int ejemplo[4]; Podemos acceder a cada uno de los valores individuales indicando su nombre (ejemplo) y el nmero de elemento que nos interesa, pero con una precaucin: se empieza a numerar desde 0, as que en el caso anterior tendramos 4 elementos, que seran ejemplo[0], ejemplo[1], ejemplo[2], ejemplo[3]. Como ejemplo, vamos a definir un grupo de 5 nmeros enteros y hallar su suma:
/*---------------------------*/ /* Ejemplo en C n 38: */ /* C038.C */ /* */ /* Primer ejemplo de tablas */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { int numero[5]; int suma;

/* Un array de 5 nmeros enteros */ /* Un entero que ser la suma */

numero[0] = 200; /* Les damos valores */ numero[1] = 150; numero[2] = 100; numero[3] = -50; numero[4] = 300; suma = numero[0] + /* Y hallamos la suma */ numero[1] + numero[2] + numero[3] + numero[4]; printf("Su suma es %d", suma); /* Nota: esta es la forma ms ineficiente e incmoda */ /* Ya lo iremos mejorando */ return 0; }

Ejercicios propuestos:

Un programa que pida al usuario 4 nmeros, los memorice (utilizando una tabla), calcule su media aritmtica y despus muestre en pantalla la media y los datos tecleados. Un programa que pida al usuario 5 nmeros reales y luego los muestre en el orden contrario al que se introdujeron.

5.1.2. Valor inicial de una tabla Al igual que ocurra con las variables normales, podemos dar valor a los elementos de una tabla al principio del programa. Ser ms cmodo que dar los valores uno por uno, como hemos hecho antes. Esta vez los indicaremos todos entre llaves, separados por comas:
/*---------------------------*/ /* Ejemplo en C n 39: */ /* C039.C */ /* */ /* Segundo ejemplo de */ /* tablas */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { int numero[5] = /* Un array de 5 nmeros enteros */ {200, 150, 100, -50, 300}; int suma; /* Un entero que ser la suma */ suma = numero[0] + /* Y hallamos la suma */ numero[1] + numero[2] + numero[3] + numero[4]; printf("Su suma es %d", suma); /* Nota: esta forma es algo menos engorrosa, pero todava no */ /* est bien hecho. Lo seguiremos mejorando */ return 0; }

Ejercicios propuestos: Un programa que almacene en una tabla el nmero de das que tiene cada mes (supondremos que es un ao no bisiesto), pida al usuario que le indique un mes (1=enero, 12=diciembre) y muestre en pantalla el nmero de das que tiene ese mes. Un programa que almacene en una tabla el nmero de das que tiene cada mes (ao no bisiesto), pida al usuario que le indique un mes (ej. 2 para febrero) y un da (ej. el da 15) y diga qu nmero de da es dentro del ao (por ejemplo, el 15 de febrero sera el da nmero 46, el 31 de diciembre sera el da 365).

5.1.3. Recorriendo los elementos de una tabla Es de esperar que exista una forma ms cmoda de acceder a varios elementos de un array, sin tener siempre que repetirlos todos, como hemos hecho en suma = numero[0] + numero[1] + numero[2] + numero[3] + numero[4]; El truco consistir en emplear cualquiera de las estructuras repetitivas que ya hemos visto (while, do..while, for), por ejemplo as: suma = 0; /* Valor inicial */ for (i=0; i<=4; i++) suma += numero[i]; En este caso, que slo sumbamos 5 nmeros, no hemos escrito mucho menos, pero si trabajsemos con 100, 500 o 1000 nmeros, la ganancia en comodidad s que est clara. Ejercicios propuestos: A partir del programa propuesto en 5.1.2, que almacenaba en una tabla el nmero de das que tiene cada mes, crear otro que pida al usuario que le indique la fecha, detallando el da (1 al 31) y el mes (1=enero, 12=diciembre), como respuesta muestre en pantalla el nmero de das que quedan hasta final de ao. Crear un programa que pida al usuario 10 nmeros y luego los muestre en orden inverso (del ltimo al primero). Crear un programa que pida al usuario 10 nmeros, calcule su media y luego muestre los que estn por encima de la media. Un programa que pida al usuario 10 nmeros enteros y calcule (y muestre) cul es el mayor de ellos.

5.2. Cadenas de caracteres

5.2.1. Definicin. Lectura desde teclado Para las cadenas de texto, la situacin se complica un poco: se crean como arrays de caracteres. Estn formadas por una sucesin de caracteres terminada con un carcter nulo (\0), de modo que tendremos que reservar una letra ms de las que necesitamos. Por ejemplo, para guardar el texto Hola usaramos char saludo[5]. Este carcter nulo lo utilizarn todas las rdenes estndar que tienen que ver con manejo de cadenas: las que las muestran en pantalla, las que comparan cadenas, las que dan a una cadena un cierto valor, etc. Por tanto, si no queremos usar esas funciones y slo vamos a acceder letra a letra (como hemos hecho con los nmeros en los ltimos ejemplos) nos bastara con char saludo[4], pero si queremos usar cualquiera de esta posibilidades (ser lo habitual), deberemos tener la prudencia de reservar una letra ms de las necesarias, para ese carcter

nulo, que indica el final de la cadena, y que todas esas rdenes utilizan para saber cuando deben terminar de manipular la cadena. Un primer ejemplo que nos pidiese nuestro nombre y nos saludase sera:
/*---------------------------*/ /* Ejemplo en C n 40: */ /* C040.C */ /* */ /* Primer ejemplo de */ /* cadenas de texto */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { char texto[40];

/* Para guardar hasta 39 letras */

printf("Introduce tu nombre: "); scanf("%s", &texto); printf("Hola, %s\n", texto); return 0; }

Dos comentarios:

Si la cadena contiene espacios, se lee slo hasta el primer espacio. Esto se puede considerar una ventaja o un inconveniente, segn el uso que se le quiera dar. En cualquier caso, dentro de muy poco veremos cmo evitarlo si queremos. Siendo estrictos, no hace falta el & en scanf cuando estamos leyendo cadenas de texto (s para los dems tipos de datos). Los motivos exactos los veremos ms adelante, cuando hablemos de direcciones de memoria y de punteros. Pero este programa se podra haber escrito as:

/*---------------------------*/ /* Ejemplo en C n 41: */ /* C041.C */ /* */ /* Segundo ejemplo de */ /* cadenas de texto: scanf */ /* sin & */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main()

{ char texto[40]; /* Para guardar hasta 39 letras */ printf("Introduce tu nombre: "); scanf("%s", texto); printf("Hola, %s\n", texto); return 0; }

Ejercicio propuesto: Un programa que te pida tu nombre y una cifra numrica, y escriba tu nombre tantas veces como indique esa cifra numrica. Un programa similar al anterior, pero que pida en primer lugar la cifra numrica y despus tu nombre, y luego escriba el nombre tantas veces como indique esa cifra numrica. 5.2.2. Cmo acceder a las letras que forman una cadena Podemos leer (o modificar) una de las letras de una cadena de igual forma que leemos o modificamos los elementos de cualquier tabla: el primer elemento ser texto[0], el segundo ser texto[1] y as sucesivamente:
/*---------------------------*/ /* Ejemplo en C n 42: */ /* C042.C */ /* */ /* Tercer ejemplo de */ /* cadenas de texto: */ /* acceder letra a letra */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { char texto[40];

/* Para guardar hasta 39 letras */

printf("Introduce tu nombre: "); scanf("%s", texto); printf("Hola, %s. Tu inicial es %c\n", texto, texto[0]); return 0; }

Ejercicio propuesto: Un programa que pida al usuario que introduzca una palabra, cambie su primera letra por una "A" y muestre la palabra resultante. 5.2.3. Longitud de la cadena.

En una cadena que definamos como char texto[40] lo habitual es que realmente no ocupemos las 39 letras que podramos llegar a usar. Si guardamos 9 letras (y el carcter nulo que marca el final), tendremos 30 posiciones que no hemos usado. Pero estas 30 posiciones generalmente contendrn basura, lo que hubiera previamente en esas posiciones de memoria, porque el compilador las reserva para nosotros pero no las limpia. Si queremos saber cual es la longitud real de nuestra cadena tenemos dos opciones: > Podemos leer la cadena carcter por carcter desde el principio hasta que encontremos el carcter nulo (\0) que marca el final. > Hay una orden predefinida que lo hace por nosotros, y que nos dice cuantas letras hemos usado realmente en nuestra cadena. Es strlen, que se usa as:
/*---------------------------*/ /* Ejemplo en C n 43: */ /* C043.C */ /* */ /* Longitud de una cadena */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h> int main() { char texto[40]; printf("Introduce una palabra: "); scanf("%s", texto); printf("Has tecleado %d letras", strlen(texto)); return 0; }

Como es de esperar, si escribimos Hola, esta orden nos dir que hemos tecleado 4 letras (no cuenta el \0 que se aade automticamente al final). Si empleamos strlen, o alguna de las otras rdenes relacionadas con cadenas de texto que veremos en este tema, debemos incluir <string.h> , que es donde se definen todas ellas. Ejercicios propuestos: Un programa que te pida tu nombre y lo muestre en pantalla separando cada letra de la siguiente con un espacio. Por ejemplo, si tu nombre es Juan, debera aparecer en pantalla J u a n. Un programa que te pida tu nombre y lo muestre en pantalla separando al revs. Por ejemplo, si tu nombre es Juan, debera aparecer en pantalla nauJ. 5.2.4. Entrada/salida para cadenas: gets, puts

Hemos visto que si leemos una cadena de texto con scanf, se paraba en el primer espacio en blanco y no segua leyendo a partir de ese punto. Existen otras rdenes que estn diseadas especficamente para manejar cadenas de texto, y que nos podrn servir en casos como ste. Para leer una cadena de texto (completa, sin parar en el primer espacio), usaramos la orden gets, as: gets(texto); De igual modo, para escribir un texto en pantalla podemos usar puts, que muestra la cadena de texto y avanza a la lnea siguiente: puts(texto); Sera equivalente a esta otra orden: printf("%s\n", texto); Ejercicio propuesto: Un programa que te pida una frase y la muestre en pantalla sin espacios. Por ejemplo, si la frase es Hola, como ests, debera aparecer en pantalla Hola,comoests. Existe un posible problema cuando se mezcla el uso de "gets" y el de "scanf": si primero leemos un nmero, al usar "scanf("%d", ...", la variable numrica guardar el nmero... pero el Intro que pulsamos en el teclado despus de introducir ese nmero queda esperando en el buffer (la memoria intermedia del teclado). Si a continuacin leemos un segundo nmero, no hay problema, porque se omite ese Intro, pero si leemos una cadena de texto, ese Intro es aceptable, porque representara una cadena vaca. Por eso, cuando primero leemos un nmero y luego una cadena usando "gets", tendremos que "absorber" el Intro, o de lo contrario el texto no se leera correctamente. Una forma de hacerlo sera usando "getchar": scanf("%d", &numero); getchar(); gets(texto); Adems, existe un problema adicional: muchos compiladores que sigan el estndar C99 pueden dar el aviso de que "gets es una orden no segura y no debera utilizarse". En compiladores que sigan el estndar C11 (propuesto en diciembre de 2011), es posible que esta orden ni siquiera est disponible. Se debe a que "gets" no comprueba que haya espacio suficiente para los datos que introduzca el usuario, lo que puede dar lugar a un error de desbordamiento y a que el programa se comporte de forma imprevisible. En un fuente de prctica, creado por un principiante, no es peligroso, pero s en caso de un programa en C "profesional" que est dando servicio a una pgina Web, donde el uso de "gets" s podra suponer una vulnerabilidad. Por eso, en el estndar C11 se propone una orden "gets_s", en la que se indica el nombre de la variable pero tambin el tamao mximo permitido. En el prximo tema (ficheros, tema 6) veremos una alternativa segura a "gets" que s se puede utilizar en cualquier compilador.

Ejercicios propuestos: Un programa que te pida tu nombre (usando "gets") y una cifra numrica, y escriba tu nombre tantas veces como indique esa cifra numrica. Un programa similar al anterior, pero que pida en primer lugar la cifra numrica y despus tu nombre (con "gets"), y luego escriba el nombre tantas veces como indique esa cifra numrica. 5.2.5. Asignando a una cadena el valor de otra: strcpy, strncpy; strcat Cuando queremos dar a una variable el valor de otra, normalmente usamos construcciones como a =2, o como a = b. Pero en el caso de las cadenas de texto, esta NO es la forma correcta, no podemos hacer algo como saludo="hola" ni algo como texto1=texto2. Si hacemos algo as, haremos que las dos cadenas estn en la misma posicin de memoria, y que los cambios que hagamos a una de ellas se reflejen tambin en la otra. La forma correcta de guardar en una cadena de texto un cierto valor es: strcpy (destino, origen); Es decir, debemos usar una funcin llamada strcpy (string copy, copiar cadena), que se encuentra tambin en string.h. Vamos a ver dos ejemplos de su uso: strcpy (saludo, "hola"); strcpy (textoDefinitivo, textoProvisional); Es nuestra responsabilidad que en la cadena de destino haya suficiente espacio reservado para copiar lo que queremos. Si no es as, estaremos sobreescribiendo direcciones de memoria en las que no sabemos qu hay. Para evitar este problema, tenemos una forma de indicar que queremos copiar slo los primeros n bytes de origen, usando la funcin strncpy, as: strncpy (destino, origen, n); Vamos a ver un ejemplo, que nos pida que tecleemos una frase y guarde en otra variable slo las 4 primeras letras:
/*---------------------------*/ /* Ejemplo en C n 44: */ /* C044.C */ /* */ /* Tomar 4 letras de una */ /* cadena */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h> int main()

{ char texto1[40], texto2[40], texto3[10]; printf("Introduce un frase: "); gets(texto1); strcpy(texto2, texto1); printf("Una copia de tu texto es %s\n", texto2); strncpy(texto3, texto1, 4); printf("Y sus 4 primeras letras son %s\n", texto3); return 0; }

Finalmente, existe otra orden relacionada con estas dos: podemos aadir una cadena al final de otra (concatenarla), con strcat (destino, origen); Vamos a ver un ejemplo de su uso, que nos pida nuestro nombre, nuestro apellido y cree una nueva cadena de texto que contenga los dos, separados por un espacio:
/*---------------------------*/ /* Ejemplo en C n 45: */ /* C045.C */ /* */ /* Concatenar dos cadenas */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h> int main() { char texto1[40], texto2[40], texto3[40]; printf("Introduce tu nombre: "); gets(texto1); printf("Introduce tu apellido: "); gets(texto2); strcat(texto1, " "); /* Aado un espacio al nombre */ strcat(texto1, texto2); /* Y luego el apellido */ printf("Te llamas %s\n", texto1); return 0; }

Ejercicio propuesto: Un programa que te pida una palabra, y la almacene en la variable llamada texto. Luego deber pedir una segunda palabra, y aadirla al final de texto.

Finalmente, deber pedir una tercera palabra, y guardarla en la variable texto y en otra variable llamada texto2. 5.2.6. Comparando cadenas: strcmp Para comparar dos cadenas alfabticamente (para ver si son iguales o para poder ordenarlas, por ejemplo), usamos strcmp (cad1, cad2); Esta funcin devuelve un nmero entero, que ser:

0 si ambas cadenas son iguales. Un nmero negativo, si cadena1 < cadena2. Un nmero positivo, si cad1 > cad2.

Hay que tener cuidado, porque las cadenas se comparan como en un diccionario, pero hay que tener en cuenta ciertas cosas:

Al igual que en un diccionario, todas las palabras que empiecen por B se consideran mayores que las que empiezan por A. Si dos cadenas empiezan por la misma letra (o las mismas letras), se ordenan basndose en la primera letra diferente, tambin al igual que en el diccionario. La primera diferencia est que en que se distingue entre maysculas y minsculas. Para ms detalles, en el cdigo ASCII las maysculas aparecen antes que las minsculas, as que las palabras escritas en maysculas se consideran menores que las palabras escritas en minsculas. Por ejemplo, ala es menor que hola, porque una empieza por a y la otra empieza por h, pero Hola es menor que ala porque la primera empieza con una letra en maysculas y la segunda con una letra en minsculas. La segunda diferencia es que el cdigo ASCII estndar no incluye ee, vocales acentuadas ni caracteres internacionales, as que estos caracteres extraos aparecen despus de los caracteres normales, de modo que adis se considera mayor que adiposo, porque la o acentuada est despus de todas las letras del alfabeto ingls.

Vamos a ver un primer ejemplo que nos pida dos palabras y diga si hemos tecleado la misma las dos veces:
/*---------------------------*/ /* Ejemplo en C n 46: */ /* C046.C */ /* */ /* Comparar dos cadenas */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h>

int main() { char texto1[40], texto2[40]; printf("Introduce una palabra: "); gets(texto1); printf("Introduce otra palabra: "); gets(texto2); if (strcmp(texto1, texto2)==0) printf("Son iguales\n"); else printf("Son distintas\n"); return 0; }

Podemos mejorarlo ligeramente para que nos diga qu palabra es menor de las dos:
/*---------------------------*/ /* Ejemplo en C n 47: */ /* C047.C */ /* */ /* Comparar dos cadenas (2) */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h> int main() { char texto1[40], texto2[40]; int comparacion; printf("Introduce una palabra: "); gets(texto1); printf("Introduce otra palabra: "); gets(texto2); comparacion = strcmp(texto1, texto2); if (comparacion==0) printf("Son iguales\n"); else if (comparacion>0) printf("La primera palabra es mayor\n"); else printf("La segunda palabra es mayor\n"); return 0;

Ejercicio propuesto: Crear un programa que pida al usuario su contrasea. Deber terminar cuando introduzca como contrasea la palabra "clave", pero volvrsela a pedir tantas veces como sea necesario. Crear un programa que pida al usuario su nombre y su contrasea, y no le permita seguir hasta que introduzca como nombre "Pedro" y como contrasea "Peter". 5.2.7. Otras funciones de cadenas: sprintf, sscanf, strstr, Hay dos posibilidades ms de las cadenas de texto que merece la pena comentar. Son las que nos ofrecen las funciones sprintf y sscanf: La funcion sprintf crea una cadena de texto a partir de una especificacin de formato y unos ciertos parmetros, al igual que hace printf, pero la diferencia est en que printf manda su salida a la pantalla, mientras que sprintf la deja guardada en una cadena de texto. Por ejemplo, si escribimos printf(El nmero %d multiplicado por 2 vale %d\n, 50, 50*2); En pantalla aparecer escrito El nmero 50 multiplicado por 2 vale 100 Pues bien, si tenemos una cadena de texto que hayamos definido (por ejemplo) como char cadena[100] y escribimos sprintf(cadena,El nmero %d multiplicado por 2 vale %d\n, 50, 50*2); Esta vez en pantalla no aparece nada escrito, sino que cadena pasa a contener el texto que antes habamos mostrado. Ahora ya podramos escribir este texto con: puts(cadena); o bien con printf(%s, cadena); Qu utilidad tiene esta orden? Nos puede resultar cmoda cuando queramos formatear texto que no vaya a aparecer directamente en pantalla de texto, sino que lo vayamos a enviar a un fichero, o que queramos mostrar en pantalla grfica, o enviar a travs de una red mediante sockets, por ejemplo. Por otra parte sscanf es similar a scanf, con la diferencia de que los valores para las variables no se leen desde el teclado, sino desde una cadena de texto strcpy(cadena, "20 30"); sscanf(cadena, "%d %d", &primerNum, &segundoNum);

Nota: sscanf devuelve el nmero de valores que realmente se han detectado, de modo que podemos comprobar si ha tomado todos los que esperbamos o alguno menos (porque el usuario haya tecleado menos de los que esperbamos o porque alguno est tecleado incorrectamente). if (sscanf(cadena, "%d %d", &primerNum, &segundoNum)<2) printf("Debia teclear dos numeros"); Ejercicio propuesto: Un programa que pida tu nombre, tu da de nacimiento y tu mes de nacimiento y lo junte todo en una cadena, separando el nombre de la fecha por una coma y el da del mes por una barra inclinada, as: Juan, nacido el 31/12. Una tercera orden que puede resultar til ms de una vez es strstr. Permite comprobar si una cadena contiene un cierto texto. Devuelve NULL (un valor especial, que nos encontraremos cada vez ms a partir de ahora) si no la contiene, y otro valor (no daremos ms detalles por ahora sobre qu tipo de valor ni por qu) en casi de que s la contenga: if (strstr (frase, "Hola ") == NULL) printf("No has dicho la palabra Hola "); Nota: estas no son todas las posibilidades que tenemos para manipular cadenas, pero posiblemente s son las ms habituales. Hay otras que nos permiten buscar una letra dentro de una cadena (strchr), una cadena dentro de otra cadena (strstr), dar la vuelta a una cadena (strrev), etc. Segn el compilador que usemos, podemos tener incluso funciones ya preparadas para convertir una cadena a maysculas (strupr) o a minsculas (strlwr). 5.2.8. Valor inicial de una cadena de texto Podemos dar un valor inicial a una cadena de texto, usando dos formatos distintos: El formato clsico para dar valores a tablas:
char nombre[50]= {'J','u','a','n'};

O bien un formato ms compacto:

char nombre[50]="Juan";

Pero cuidado con este ltimo formato: hay que recordar que slo se puede usar cuando se declara la variable, al principio del programa. Si ya estamos dentro del programa, deberemos usar necesariamente la orden strcpy para dar un valor a una cadena de texto.

5.3. Tablas bidimensionales

Podemos declarar tablas de dos o ms dimensiones. Por ejemplo, si queremos guardar datos de dos grupos de alumnos, cada uno de los cuales tiene 20 alumnos, tenemos dos opciones: > Podemos usar int datosAlumnos[40] y entonces debemos recordar que los 20 primeros datos corresponden realmente a un grupo de alumnos y los 20 siguientes a otro grupo.

> O bien podemos emplear int datosAlumnos[2][20] y entonces sabemos que los datos de la forma datosAlumnos[0][i] son los del primer grupo, y los datosAlumnos[1][i] son los del segundo. En cualquier caso, si queremos indicar valores iniciales, lo haremos entre llaves, igual que si fuera una tabla de una nica dimensin. Vamos a verlo con un ejemplo de su uso:
/*---------------------------*/ /* Ejemplo en C n 48: */ /* C048.C */ /* */ /* Array de dos dimensiones */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { int notas[2][10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }; printf("La nota del tercer alumno del grupos 1 es %d", notas[0][2]); return 0; }

Este tipo de tablas son las que se usan tambin para guardar matrices, cuando hay que resolver problemas matemticos ms complejos. Tambin podemos usar arrays de dos dimensiones si queremos guardar una lista de cadenas de texto, como en este ejemplo:
/*---------------------------*/ /* Ejemplo en C n 49: */ /* C049.C */ /* */ /* Array de cadenas */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { char mensajeError[5][80] = { "Fichero no encontrado", "El fichero no se puede abrir para escritura",

"El fichero est vaco", "El fichero contiene datos de tipo incorrecto" "El fichero est siendo usado" }; printf("El segundo mensaje de error es: %s", mensajeError[1]); printf("La primera letra del tercer mensaje de error es: %c", mensajeError[2][0]); return 0; }

Ejercicios propuestos : Un programa guarde los nombres de los meses. El usuario deber indicar un nmero de mes (por ejemplo, 3) y se le mostrar el nombre de dicho mes (por ejemplo, Marzo). Usar un array de 3 dimensiones para guardar los nombres de los meses en espaol e ingls. El usuario deber indicar un nmero de mes (por ejemplo, 3) y se le mostrar el nombre de dicho mes en espaol (Marzo) y en ingls (March).

5.4. Arrays indeterminados.

Si damos un valor inicial a un array, no ser necesario que indiquemos su tamao, porque el compilador lo puede saber contando cuantos valores hemos detallado, as:
int punto[] = {10, 0, -10}; char saludo[ ] = "hola"; char mensajes[][80] = {"Bienvenido", "Hasta otra"};

Ejercicios propuestos: Un programa que pida 10 nombres y los memorice. Despus deber pedir que se teclee un nombre y dir si se encuentra o no entre los 10 que se han tecleado antes. Volver a pedir otro nombre y a decir si se encuentra entre ellos, y as sucesivamente hasta que se teclee fin. Un programa que prepare espacio para un mximo de 100 nombres (de un mximo de 80 letras cada uno). El usuario deber ir introduciendo un nombre cada vez, hasta que se pulse Intro sin teclear nada, momento en el que dejarn de pedirse ms nombres y se mostrar en pantalla la lista de los nombres que se han introducido.

5.5. Estructuras 5.5.1. Definicin y acceso a los datos

Un registro es una agrupacin de datos, los cuales no necesariamente son del mismo tipo. Se definen con la palabra struct.

Para acceder a cada uno de los datos que forman el registro, tanto si queremos leer su valor como si queremos cambiarlo, se debe indicar el nombre de la variable y el del dato (o campo) separados por un punto:
/*---------------------------*/ /* Ejemplo en C n 50: */ /* C050.C */ /* */ /* Registros (struct) */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> int main() { struct { char inicial; int edad; float nota; } persona; persona.inicial = 'J'; persona.edad = 20; persona.nota = 7.5; printf("La edad es %d", persona.edad); return 0; }

Como es habitual en C, para declarar la variable hemos indicado primero el tipo de datos (struct { ...} ) y despus el nombre que tendr esa variable (persona). Tambin podemos declarar primero cmo van a ser nuestros registros, y ms adelante definir variables de ese tipo:
/*---------------------------*/ /* Ejemplo en C n 51: */ /* C051.C */ /* */ /* Registros (2) */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> struct datosPersona { char inicial; int edad;

float nota; }; int main() { struct datosPersona ficha; ficha.inicial = 'J'; ficha.edad = 20; ficha.nota = 7.5; printf("La edad es %d", ficha.edad); return 0; }

Ejercicios propuestos: Un struct que almacene datos de una cancin en formato MP3: Artista, Ttulo, Duracin (en segundos), Tamao del fichero (en KB). Un programa debe pedir los datos de una cancin al usuario, almacenarlos en dicho struct y despus mostrarlos en pantalla. 5.5.2. Arrays de estructuras Hemos guardado varios datos de una persona. Se pueden almacenar los de varias personas si combinamos el uso de los struct con las tablas (arrays) que vimos anteriormente. Por ejemplo, si queremos guardar los datos de 100 alumnos podramos hacer:
struct { char inicial; int edad; float nota; } alumnos[100];

La inicial del primer alumno sera alumnos[0].inicial, y la edad del ltimo sera alumnos[99].edad. Ejercicios propuestos: Ampliar el programa del apartado 5.5.1, para que almacene datos de hasta 100 canciones. Deber tener un men que permita las opciones: aadir una nueva cancin, mostrar el ttulo de todas las canciones, buscar la cancin que contenga un cierto texto (en el artista o en el ttulo). Un programa que permita guardar datos de "imgenes" (ficheros de ordenador que contengan fotografas o cualquier otro tipo de informacin grfica). De cada imagen se debe guardar: nombre (texto), ancho en pxeles (por ejemplo 2000), alto en pxeles (por ejemplo, 3000), tamao en Kb (por ejemplo 145,6). El programa debe ser capaz de almacenar hasta 700 imgenes (deber avisar cuando su capacidad est llena). Debe permitir las opciones: aadir una ficha nueva, ver todas las fichas (nmero y nombre de cada imagen), buscar la ficha que tenga un cierto nombre.

5.5.3. Estructuras anidadas Podemos encontrarnos con un registo que tenga varios datos, y que a su vez ocurra que uno de esos datos est formado por varios datos ms sencillos. Para hacerlo desde C, incluiramos un struct dentro de otro, as:
/*---------------------------*/ /* Ejemplo en C n 52: */ /* C052.C */ /* */ /* Registros anidados */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> struct fechaNacimiento { int dia; int mes; int anyo; }; struct { char inicial; struct fechaNacimiento diaDeNacimiento; float nota; } persona; int main() { persona.inicial = 'I'; persona.diaDeNacimiento.mes = 8; persona.nota = 7.5; printf("La nota es %f", persona.nota); return 0; }

Ejercicios propuestos: Ampliar el programa del primer apartado de 5.5.2, para que el campo duracin se almacene como minutos y segundos, usando un struct anidado que contenga a su vez estos dos campos.

5.6 Ejemplo completo

Vamos a hacer un ejemplo completo que use tablas (arrays), registros (struct) y que adems manipule cadenas.

La idea va a ser la siguiente: Crearemos un programa que pueda almacenar datos de hasta 1000 ficheros (archivos de ordenador). Para cada fichero, debe guardar los siguientes datos: Nombre del fichero (max 40 letras), Tamao (en KB, nmero de 0 a 2.000.000.000). El programa mostrar un men que permita al usuario las siguientes operaciones: 1- Aadir datos de un nuevo fichero 2- Mostrar los nombres de todos los ficheros almacenados 3- Mostrar ficheros que sean de ms de un cierto tamao (por ejemplo, 2000 KB). 4- Ver todos los datos de un cierto fichero (a partir de su nombre) 5- Salir de la aplicacin (como todava no sabemos almacenar los datos, stos se perdern). No debera resultar difcil. Vamos a ver directamente una de las formas en que se podra plantear y luego comentaremos alguna de las mejoras que se podra (incluso se debera) hacer. Una opcin que podemos a tomar para resolver este problema es la de contar el nmero de fichas que tenemos almacenadas, y as podremos aadir de una en una. Si tenemos 0 fichas, deberemos almacenar la siguiente (la primera) en la posicin 0; si tenemos dos fichas, sern la 0 y la 1, luego aadiremos en la posicin 2; en general, si tenemos n fichas, aadiremos cada nueva ficha en la posicin n. Por otra parte, para revisar todas las fichas, recorreremos desde la posicin 0 hasta la n-1, haciendo algo como for (i=0; i<=n-1; i++) { ... ms rdenes ...} o bien algo como for (i=0; i<n; i++) { ... ms rdenes ...} El resto del programa no es difcil: sabemos leer y comparar textos y nmeros. Slo haremos tres consideraciones:

Los textos (nombre del fichero, por ejemplo) pueden contener espacios, por lo que usaremos gets en vez de scanf. Es peligroso mezclar rdenes gets y scanf: si leemos un nmero con scanf, la pulsacin de la tecla Intro posterior se queda en el buffer del teclado, lo que puede provocar que despus intentemos leer con gets un texto, pero slo leamos esa pulsacin de la tecla Intro. Para evitarlo, los nmeros los leeremos en dos etapas: primero leeremos una cadena con gets y luego la convertiremos a nmero con sscanf. Hemos limitado el nmero de fichas a 1000, as que, si nos piden aadir, deberamos asegurarnos antes de que todava tenemos hueco disponible.

Con todo esto, nuestro fuente quedara as:

/*---------------------------*/ /* Ejemplo en C n 53: */ /* C053.C */ /* */

/* Tabla con muchos struct */ /* y menu para manejarla */ /* */ /* Curso de C, */ /* Nacho Cabanes */ /*---------------------------*/ #include <stdio.h> #include <string.h> struct{ char nombreFich[41]; unsigned long tamanyo; } fichas[1000]; int numeroFichas=0; int i; int opcion; /* Nombre del fichero */ /* El tamao en bytes */

/* Nmero de fichas que ya tenemos */ /* Para bucles */ /* La opcion del menu que elija el usuario */

char textoTemporal[40]; /* Para cuando preguntemos al usuario */ unsigned long numeroTemporal; int main() { do { /* Menu principal */ printf("Escoja una opcin:\n"); printf("1.- Aadir datos de un nuevo fichero\n"); printf("2.- Mostrar los nombres de todos los ficheros\n"); printf("3.- Mostrar ficheros que sean de mas de un cierto tamao\n"); printf("4.- Ver datos de un fichero\n"); printf("5.- Salir\n"); /* Para evitar problemas con datos mal introducidos, leemos con "gets" y luego lo filtramos con "sscanf" */ gets (textoTemporal); sscanf(textoTemporal, "%d", &opcion); /* Hacemos una cosa u otra segn la opcin escogida */ switch(opcion){ case 1: /* Aadir un dato nuevo */ if (numeroFichas < 1000) { /* Si queda hueco */ printf("Introduce el nombre del fichero: "); gets(fichas[numeroFichas].nombreFich); printf("Introduce el tamao en KB: "); gets(textoTemporal); sscanf(textoTemporal,"%ld",&fichas[numeroFichas].tamanyo); /* Y ya tenemos una ficha ms */ numeroFichas++; } else /* Si no hay hueco para ms fichas, avisamos */ printf("Mximo de fichas alcanzado (1000)!\n"); break; case 2: /* Mostrar todos */ for (i=0; i<numeroFichas; i++) printf("Nombre: %s; Tamao: %ld Kb\n",

fichas[i].nombreFich, fichas[i].tamanyo); break; case 3: /* Mostrar segn el tamao */ printf("A partir de que tamao quieres que te muestre?"); gets(textoTemporal); sscanf(textoTemporal, "%ld", &numeroTemporal); for (i=0; i<numeroFichas; i++) if (fichas[i].tamanyo >= numeroTemporal) printf("Nombre: %s; Tamao: %ld Kb\n", fichas[i].nombreFich, fichas[i].tamanyo); break; case 4: /* Ver todos los datos (pocos) de un fichero */ printf("De qu fichero quieres ver todos los datos?"); gets(textoTemporal); for (i=0; i<numeroFichas; i++) if (strcmp(fichas[i].nombreFich, textoTemporal) == 0) printf("Nombre: %s; Tamao: %ld Kb\n", fichas[i].nombreFich, fichas[i].tamanyo); break; case 5: /* Salir: avisamos de que salimos */ printf("Fin del programa\n"); break; default: /* Otra opcion: no vlida */ printf("Opcin desconocida!\n"); break; } } while (opcion != 5); /* Si la opcion es 5, terminamos */ return 0; }

Funciona, y hace todo lo que tiene que hacer, pero es mejorable. Por supuesto, en un caso real es habitual que cada ficha tenga que guardar ms informacin que slo esos dos apartados de ejemplo que hemos previsto esta vez. Si nos muestra todos los datos en pantalla y se trata de muchos datos, puede ocurrir que aparezcan en pantalla tan rpido que no nos d tiempo a leerlos, as que sera deseable que parase cuando se llenase la pantalla de informacin (por ejemplo, una pausa tras mostrar cada 25 datos). Por supuesto, se nos pueden ocurrir muchas ms preguntas que hacerle sobre nuestros datos. Y adems, cuando salgamos del programa se borrarn todos los datos que habamos tecleado, pero eso es lo nico casi inevitable, porque an no sabemos manejar ficheros.

Ejercicios propuestos:

Un programa que pida el nombre, el apellido y la edad de una persona, los almacene en un struct y luego muestre los tres datos en una misma lnea, separados por comas. Un programa que pida datos de 8 personas: nombre, dia de nacimiento, mes de nacimiento, y ao de nacimiento (que se deben almacenar en una tabla de structs). Despus deber repetir lo siguiente: preguntar un nmero de mes y

mostrar en pantalla los datos de las personas que cumplan los aos durante ese mes. Terminar de repetirse cuando se teclee 0 como nmero de mes. Un programa que sea capaz de almacenar los datos de 50 personas: nombre, direccin, telfono, edad (usando una tabla de structs). Deber ir pidiendo los datos uno por uno, hasta que un nombre se introduzca vaco (se pulse Intro sin teclear nada). Entonces deber aparecer un men que permita: o Mostrar la lista de todos los nombres. o Mostrar las personas de una cierta edad. o Mostrar las personas cuya inicial sea la que el usuario indique. o Salir del programa (lgicamente, este men debe repetirse hasta que se escoja la opcin de salir). Mejorar la base de datos de ficheros (ejemplo 53) para que no permita introducir tamaos incorrectos (nmeros negativos) ni nombres de fichero vacos. Ampliar la base de datos de ficheros (ejemplo 53) para que incluya una opcin de bsqueda parcial, en la que el usuario indique parte del nombre y se muestre todos los ficheros que contienen ese fragmento (usando strstr). Ampliar la base de datos de ficheros (ejemplo 53) para que se pueda borrar un cierto dato (habr que mover hacia atrs todos los datos que haba despus de ese, y disminuir el contador de la cantidad de datos que tenemos). Mejorar la base de datos de ficheros (ejemplo 53) para que se pueda modificar un cierto dato a partir de su nmero (por ejemplo, el dato nmero 3). En esa modificacin, se deber permitir al usuario pulsar Intro sin teclear nada, para indicar que no desea modificar un cierto dato, en vez de reemplazarlo por una cadena vaca. Ampliar la base de datos de ficheros (ejemplo 53) para que se permita ordenar los datos por nombre. Para ello, debers buscar informacin sobre algn mtodo de ordenacin sencillo, como el "mtodo de burbuja" (en el siguiente apartado tienes algunos), y aplicarlo a este caso concreto.

5.7 Ordenaciones simples

Es muy frecuente querer ordenar datos que tenemos en un array. Para conseguirlo, existen varios algoritmos sencillos, que no son especialmente eficientes, pero son fciles de programar. La falta de eficiencia se refiere a que la mayora de ellos se basan en dos bucles for anidados, de modo que en cada pasada quede ordenado un dato, y se dan tantas pasadas como datos existen, de modo que para un array con 1.000 datos, podran llegar a tener que hacerse un milln de comparaciones.

Existen ligeras mejoras (por ejemplo, cambiar uno de los for por un while, para no repasar todos los datos si ya estaban parcialmente ordenados), as como

mtodos claramente ms efectivos, pero ms difciles de programar, alguno de los cuales veremos ms adelante.

Veremos tres de estos mtodos simples de ordenacin, primero mirando la apariencia que tiene el algoritmo, y luego juntando los tres en un ejemplo que los pruebe:

Mtodo de burbuja (Intercambiar cada pareja consecutiva que no est ordenada)

Para i=1 hasta n-1 Para j=i+1 hasta n Si A[i] > A[j] Intercambiar ( A[i], A[j])

(Nota: algunos autores hacen el bucle exterior creciente y otros decreciente, as:)
Para i=n descendiendo hasta 1 Para j=2 hasta i Si A[j-1] > A[j] Intercambiar ( A[j-1], A[j])

Seleccin directa (En cada pasada busca el menor, y lo intercambia al final de la pasada)
Para i=1 hasta n-1 menor = i Para j=i+1 hasta n Si A[j] < A[menor] menor = j Si menor <> i Intercambiar ( A[i], A[menor])

Insercin directa (Comparar cada elemento con los anteriores -que ya estn ordenados- y desplazarlo hasta su posicin correcta).
Para i=2 hasta n j=i-1 mientras (j>=1) y (A[j] > A[j+1]) Intercambiar ( A[j], A[j+1]) j = j - 1

(Es mejorable, no intercambiando el dato que se mueve con cada elemento, sino slo al final de cada pasada, pero no entraremos en ms detalles). Ejercicios propuestos:

Un programa que cree un array de 7 nmeros enteros y lo ordene con cada uno de estos tres mtodos, mostrando el resultado de los pasos intermedios.

/* Realizar un programa Orientado a Objetos, que permita para M matrices: 1. Ingresar el numero de filas y numero de columnas 2. Ingresar datos a las matrices Para cada Objeto se pide: a. Calcular el porcentaje de los datos que estn por encima del promedio de cada matriz b. Ordenar la matriz de mayor a menor por filas de la primera a la ultima y de izquierda a derecha c. Hallar e imprimir la matriz transpuesta de cada matriz Para todos los objetos: a. Cuantos datos estn por encima del promedio de los datos de todas las matrices b. Calcular la suma de los datos primos que estn por debajo del promedio de los datos pares de todas las matrices

*/

#include<iostream> #include<iomanip> #include<conio.h> #include<math.h>

using namespace System; using namespace std; //declarar la clase de objetos class MATRICES { float F,C,J[25],N[5][5],prom,sumpar,conpar,sumdat; int M[5][5],tam; public: int totdat[25]; int conpri[25]; int FC(); void INGFC(); void DATOS(); void PROM(); void PORDATOSENC(); void ORDEN(); void TRN(); float SUMPAR(); float CONPAR(); void PRIMOS(); float SUMDAT(); float CONDAT(); void TOTALD(); }; //Implementacion de las funciones miembro de la clase

int MATRICES::FC() { return(F*C); } void MATRICES::INGFC() {

cout<<"\n Cuantas filas tiene la matriz?(maximo 5): "; cin>>F; cout<<"\n Cuantas columnas tiene la matriz?(maximo 5): "; cin>>C;

void {

MATRICES::DATOS()

int sumdat=0; for(int i=0;i<=F-1;i++)

for(int j=0;j<=C-1;j++) {

cout<<"\n M["<<i+1<<"]["<<j+1<<"]= "; cin>>M[i][j];

sumdat=sumdat+M[i][j]; } prom=sumdat/(F*C);

} } void MATRICES::PROM() { cout<<"\n el promedio de los datos de la matriz es: "<<prom<<"\n"; } void MATRICES::PORDATOSENC() { int condat=0; for(int i=0;i<=F-1;i++)

for(int j=0;j<=C-1;j++) { if(M[i][j]>prom) { condat++;

} }

} cout<<" \n El "<<(condat*100)/(F*C)<<" % de los datos estan por encima del promedio \n "; } void MATRICES::ORDEN() { int k=0; for (int u=0; u<F; u++) { for (int v=0; v<C; v++) { J[k]=M[u][v]; k++; } } for (int y=0; y<k-1; y++) { for (int x=y+1; x<k; x++) { if (J[y]<J[x]) { float Temp=J[x]; J[x]=J[y];

J[y]=Temp; } }

} int r=0; cout<<"\n Matriz ordenada: \n"; for (int a=0; a<F; a++) { cout<<"\n"; for(int b=0; b<C; b++) { N[a][b]=J[r]; r++; cout<<"\t"<<N[a][b]<<"\t"; } cout<<"\n "; } } void MATRICES::TRN() { cout<<"\n Matriz transpuesta: \n"; for(int a=0;a<=C-1;a++) { cout<<"\n"; for(int b=0;b<=F-1;b++)

{ cout<<"\t"<<N[b][a]<<"\t"; } cout<<"\n"; } } float MATRICES::SUMPAR() { sumpar=0; for (int i=0; i<=F-1; i++) { for (int j=0; j<=C-1; j++) { if (M[i][j]%2==0) { sumpar+=M[i][j]; } } } return (sumpar); } float MATRICES::CONPAR() { conpar=0; for (int i=0; i<F; i++) {

for (int j=0; j<C; j++) { if ((M[i][j])%2==0) { conpar++; } } } return (conpar); } void MATRICES::PRIMOS() { int A=0, B=0, G, R;

for (int K=0; K<F; K++) { for (int L=0; L<C; L++) { for (G=1; G<=M[K][L]; G++) { R=M[K][L]%G; if (R==0) { A++; } }

if (A==2) { conpri[B]=M[K][L]; B++; } A=0; } } conpri[B]=0;

} float MATRICES::SUMDAT() { sumdat=0; for (int i=0; i<F; i++) { for (int j=0; j<C; j++) { sumdat+=M[i][j]; } } return (sumdat); } float MATRICES::CONDAT() { tam=0;

tam=F*C; return (tam); } void MATRICES::TOTALD() { int X=0; for (int i=0; i<F; i++) { for (int j=0; j<C; j++) { totdat[X]=M[i][j]; X++; } } }

//Programa principal void main() {

//Declaracion de que objetos pertenecen a la clase MATRICES MA[10];

int M; cout<<"\n Cuantas matrices desea procesar?(maximo 10): "; cin>>M;

int m=0; int sumdpar=0,sumdpar1=0,conta=0,sumdat1=0,condat1=0,ab=0,bc=0,cd=0,acont=0 ; float VEC[250],PAR[250];

for(int y=0;y<=M-1;y++) { cout<<"\n Procesando la matriz "<<y+1<<" : \n "; MA[y].INGFC(); MA[y].DATOS(); MA[y].PROM(); MA[y].PORDATOSENC(); MA[y].ORDEN(); MA[y].TRN(); sumdpar+=MA[y].SUMPAR(); conta+=MA[y].CONPAR(); sumdat1+=MA[y].SUMDAT(); condat1+=MA[y].CONDAT(); MA[y].PRIMOS(); for(int a=0;a<M;a++) { if(MA[y].conpri[a]!=0) { PAR[a]=MA[y].conpri[a]; a++;

ab++; } } MA[y].TOTALD(); while (bc!=MA[y].FC()) { VEC[cd]=MA[y].totdat[bc]; bc++; cd++; } bc=0; } float PROMDP=sumdpar/conta; float PROMTD=sumdat1/condat1; cout<<"\n El promedio de datos pares es: "<<PROMDP; for (int t=0; t<ab; t++) { if (PAR[t]<PROMDP) { sumdpar1+=PAR[t]; } } for (int t=0; t<cd; t++) { if (VEC[t]>PROMTD) {

acont++; } } cout<<"\n La suma de datos primos que esta por encima del promedio de datos pares es: "<<sumdpar1; cout<<"\n El promedio de todos los datos es: "<<PROMTD;

cout<<"\n Los datos que estan por encima del promedio de todos los datos son: "<<acont; getch(); }

#include<stdio.h> #include<conio.h> //estos son los 2 registros// struct reg1 { char nombre [25],carrera,sexo; int codigo,edad; float prom; }alumno[100];

struct

reg2 { int cod; char nombre[25],carrera[5]; }maestro[20];

//aki empiezan las funciones para alumnos// void regalum(int i) { printf("ingresa tu nombre \n"); fflush(stdin); gets(alumno[i].nombre); printf("ingresa tu codigo \n"); scanf("%i",&alumno[i].codigo); printf("ingresa tu carrera:a)informatica b)computacion c)industrial d)com y elec e)civil f)ing quimica g)contaduria h)administracio"); scanf("%c",&alumno[i].carrera); printf("ingresa tu edad"); scanf("%i",&alumno[i].edad); printf("introduce tu sexo:m)mujer h)hombre p)marica"); scanf("%c",&alumno[i].sexo); printf("introduce tu promedio"); scanf("%f",&alumno[i].prom);

} void muestra1(int i) { printf("codigo:%i",alumno[i].codigo); printf("nombre:%c",alumno[i].nombre); printf("carrer:%c",alumno[i].carrera); printf("sexo:%c",alumno[i].sexo); printf("edad:%i",alumno[i].edad); printf("promedio:%f",alumno[i].prom); } void buscaalumno() { char bus,cr; int i,cd; printf("deseas buscar por: 1)codigo 2) carrera??"); scanf("%i",&bus); if(bus==1) printf("introduce el codigo"); scanf("%i",&cd); { for(i=0;i>20;i++){ if(alumno[i].codigo==cd) printf("%i",alumno[i].codigo);}}

if(bus==2) printf("introduce la carrera que quiereas buscar a)informatica b)computacion c)industrial d)com y elec e)civil f)ing quimica g)contaduria h)administracion "); scanf("%c",&cr); for(i=0;i>20;i++){ if(cr==alumno[i].carrera) printf("%c",alumno[i].carrera); } }

//aki empiezan las funciones para los maestros// void regma(int i) { int j,k; printf("ingresa tu nombre \n"); fflush(stdin); gets(maestro[i].nombre); printf("ingresa tu codigo \n"); scanf("%i",&maestro[i].cod); printf("ingresa el numero de carreras que impartes\n"); scanf("%i",&j);

for(k=0;k>j;k++) { printf("introduce a)informatica b)computacion c)industrial d)com y elec e)civil f)ing quimica g)contaduria h)administracion",k++); scanf("%c",maestro[i].carrera[k]); } }

void muestra2(int i) { int i2; printf("codigo:%i",maestro[i].cod); printf("nombre:%c",maestro[i].nombre); for(i2=0;i>5;i++) printf("carrera%i: %c",i2,maestro[i].carrera[i2]); } void buscamaestro() { char bus,cr; int i,cd,k; printf("deseas buscar por: 1)codigo 2) carrera??"); scanf("%i",&bus); if(bus==1)

printf("introduce el codigo"); scanf("%i",&cd); { for(i=0;i>20;i++){ if(maestro[i].cod==cd) printf("%i",maestro[i].cod);}} if(bus==2) printf("introduce la carrera que quiereas buscar a)informatica b)computacion c)industrial d)com y elec e)civil f)ing quimica g)contaduria h)administracion "); scanf("%c",&cr); for(i=0;i>20;i++) for(k=0;k>5;k++){ if(cr==maestro[i].carrera[k]) printf("%c",maestro[i].carrera[k]); } } //y aki el programa principal// void main () { int a,b,aca,numr=0,numr1=0,x,y,alla; char k;

k=1; a=1; while(a>0) { clrscr(); printf("elige la opcion que desees \n"); printf("a) maestro b)alumno"); scanf("%c",&k); switch(k) { case('a'): printf("eres maestro"); printf("\n que deeas hacer ??? 1)registrarte 2)mostrar tus datos 3) buscar algun alumno"); scanf("%i",&aca); if(aca==1) { regma(numr); printf("tu numero de registro es %i",numr+1); numr+=1; } if(aca==2){ printf("cual es tu numero de registro??");

scanf("%d",&x); muestra2(x); } if(aca==3) buscamaestro(); break; case('b'): printf("eres alumno"); printf("\n que deeas hacer ??? 1)registrarte 2)mostrar tus datos 3) buscar algun alumno"); scanf("%i",&alla); if(alla==1){ regalum(numr1); printf("tu numero de registro es:%i ",numr1+1); numr+=1;} if(alla==2) { printf("cual es tu numero de registro?"); scanf("%i",&y); muestra1(y); } if(alla==3) {

buscaalumno();} break; default: printf("te equivocaste"); break; } printf(" \n desea continuar?? oprima 1), si no 0) "); scanf("%d",&a);

} getch();

Programa que muestra los registros de un producto, para poder hacer inventarios, consultas y las muestra en pantalla, muestra las ventas que se han realizado en el sistema

#include #include #include #include #include #include #include #include #include #include #include #include

<conio.h> <stdio.h> <alloc.h> <math.h> <string.h> <conio.h> <dos.h> <ctype.h> <stdlib.h> <setjmp.h> <stdlib.h> <setjmp.h>

/********ESTRUCTURAS********/ struct alumno { char cod[45]; char nom[45]; char apel[45]; char sex; struct alumno *sig; struct notas *ady; }; struct notas { float nota; struct notas *sig; }; /********FUNCIONES********/ void cuadros1(int x1,int x2,int y1,int y2); void cuadros1(int x1,int x2,int y1,int y2); void clave(); void leer_datos(); void mostrar(); void consulta_codigo(); void modificar(); void mujeres_ganaron(); void alumnos_perdieron(); void hombres_ganaron(); void prom_mayor_trescinco(); void borrar(); void cargar(); void ordenar(); void piso_color(int piso,int color);

void void void void void void void void void void void void

ref1(); ref2(); marco(int a,int b,int c,int d); marco2(); fondo(int a,int c,int color); menu1(); menu2(); escribe_menu(); escribe_menu2(); escribe_menu3(); ayuda(); salir();

char op2[7][30]={" ","Listado General ","Mujeres que ganaron materia", "Hombres que ganaron materia","Alumnos perdieron materia", "Promedios mayores a 3.5","Salir "}; char op[6][10]={" ","Adicionar","Consultar","Eliminar ","Modificar","Salir "}; char nombre[40],apellido[40],opcion,sexo; char codigo[40]; int n,con,sw2,i,sw,c,st; float la_nota[4]; struct alumno *ptr=NULL,*auxalumn; void cuadro(int x1,int x2,int y1,int y2) { int j,i,k; textcolor(WHITE);textbackground(0); for(j=x1;j<=x2;j++) { delay(10); gotoxy(j,y1);cprintf(""); gotoxy(j,y2);cprintf(""); } for(i=y1;i<=y2-1;i++) { delay(10); gotoxy(x1,i);cprintf(""); gotoxy(x2,i);cprintf(""); } gotoxy(x1,y1);cprintf(""); gotoxy(x2,y1);cprintf(""); gotoxy(x1,y2);cprintf(""); gotoxy(x2,y2);cprintf(""); textcolor(WHITE);textbackground(0); } void cuadros1(int x1,int x2,int y1,int y2) { int j,i,k; textcolor(WHITE);textbackground(0);

for(j=x1;j<=x2;j++) { delay (10); gotoxy(j,y1);cprintf(""); gotoxy(j,y2);cprintf(""); } for(i=y1;i<=y2-1;i++) { delay(10); gotoxy(x1,i);cprintf(""); gotoxy(x2,i);cprintf(""); } gotoxy(x1,y1);cprintf(""); gotoxy(x2,y1);cprintf(""); gotoxy(x1,y2);cprintf(""); gotoxy(x2,y2);cprintf(""); textcolor(WHITE);textbackground(0); } void clave() { char cl[12],ceci[12],activa; int i,x,j ; textcolor(WHITE);textbackground(0); activa='n'; strcpy(ceci,"9810402667"); x=1; while((x<=3) && (activa=='n')) { j=45; clrscr();cuadros1(1,79,1,24);cuadros1(15,59,3,5);cuadros1(21,55,11,13); gotoxy(20,4);printf("OPCION:CLAVE DE ACCESO AL SISTEMA"); gotoxy(22,12); printf("DIGITE CLAVE DE ACCESO:"); for(i=0;i<10;i++) { gotoxy(j,12);cl[i]=getch();gotoxy(j,12);printf("*"); j++; } cl[i]='\0'; if(strcmp(cl,ceci)==0) { activa='s'; clrscr(); cuadros1(1,79,1,24);cuadros1(15,59,3,5); gotoxy(20,4);printf("OPCION:CLAVE DE ACCESO AL SISTEMA"); gotoxy(29,12);printf("<<clave correcta>>"); gotoxy(15,23);printf("PULSE UNA TECLA PARA CONTINUAR.....");getch(); } else {clrscr(); cuadros1(1,79,1,24); cuadros1(28,49,11,13); textcolor(WHITE+128);textbackground(0); gotoxy(29,12);cprintf("<<clave incorrecta>>");

getch(); textcolor(WHITE);textbackground(0); } x++; } if(activa=='n') { clrscr(); gotoxy(18,10);printf(" LA CLAVE NO FUE LA CORRECTA "); gotoxy(15,23);printf(" PULSE UNA TECLA PARA CONTINUAR....."); getch(); exit(1); } } void escribe_menu2() { textbackground(BLACK); clrscr(); window(1,1,80,25); gotoxy(1,1); fondo(2,81,LIGHTGRAY); piso_color(3,BLACK); gotoxy(8,1); cprintf("Estudiante"); piso_color(WHITE,BLACK); gotoxy(26,1); cprintf("Listados"); gotoxy(46,1); cprintf("Ayuda"); gotoxy(63,1); cprintf("Salir"); gotoxy(8,1); piso_color(BLACK,WHITE); marco(2,3,78,22); gotoxy(1,24); fondo(1,159,LIGHTGRAY); piso_color(WHITE,BLACK); gotoxy(2,24); cprintf("Copyrigth (c) 1997 UDES Valledupar. Derechos reservados del Autor "); gotoxy(2,25); cprintf("Unica Versin 2 de Abril 1997 Diseo: Heyner A. Aroca Araujo Cod: 95131119"); gotoxy(8,1); } void fondo(int a,int c,int color) { int i; textcolor(color); for(i=a;i<=c;i++) cprintf("%c",219); } void marco(int a,int b,int c,int d) {

int i; window(1,1,80,25); gotoxy(a-1,b-1); cprintf("%c",''); for (i=a;i<=c;i++ ) cprintf("%c",''); cprintf("%c",''); for (i=b;i<=d;i++) { gotoxy(c+1,i); cprintf("%c",''); } gotoxy(a-1,d+1); cprintf("%c",192); for (i=a;i<=c;i++) cprintf("%c",''); cprintf("%c",''); for (i=b;i<=d;i++ ) { gotoxy(a-1,i); cprintf("%c",''); } } void marco2(int a,int b,int c,int d) { int i; window(1,1,80,25); gotoxy(a-1,b-1); cprintf("%c",''); for (i=a;i<=c;i++ ) cprintf("%c",''); cprintf("%c",''); for (i=b;i<=d;i++) { gotoxy(c+1,i); cprintf("%c",''); } gotoxy(a-1,d+1); cprintf("%c",192); for (i=a;i<=c;i++) cprintf("%c",''); cprintf("%c",''); for (i=b;i<=d;i++ ) { gotoxy(a-1,i); cprintf("%c",''); } window(a,b,c,d); } void ref1(int n,int piso,int color,char s[]) { gotoxy(n,1); piso_color(piso,color);

cprintf("%s",s); } void ref2(int n,int piso,int color,char s[]) { gotoxy(n,1); piso_color(piso,color); cprintf("%s",s); gotoxy(n,1); } void piso_color(int piso,int color) { textbackground(piso); textcolor(color); } void menu1() { int sw; char c; sw=0; piso_color(BLACK,WHITE); escribe_menu(); c = getch(); while ((c != 27)&&(sw!=1)) { switch (c) { case 80 : { piso_color (BLACK,WHITE); cprintf("%s",op[wherey()]); piso_color (WHITE,BLACK); if (wherey() == 5) gotoxy (3,1); else gotoxy (3,wherey()+1); cprintf ("%s",op[wherey()]); gotoxy (3,wherey()); break; } case 72 : { piso_color(BLACK,WHITE); cprintf("%s",op[wherey()]); piso_color (WHITE,BLACK); if (wherey() == 1) gotoxy (3,5); else gotoxy (3,wherey()-1); cprintf("%s",op[wherey()]); gotoxy (3,wherey()); break; } } c=getch(); if(c==13) { switch(wherey()) { case 1:{

piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); cargar(); clrscr(); escribe_menu(); getch(); break; } case 2:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); consulta_codigo(); clrscr(); escribe_menu(); getch(); break; } case 3:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); borrar(); clrscr(); escribe_menu(); getch(); break; } case 4:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); modificar(); clrscr(); escribe_menu(); getch(); break; } case 5:{ sw=1; break; } } } } } void escribe_menu() { int i; marco2(4,3,16,7); piso_color(BLACK,WHITE);

for(i=2;i<=5;i++) { gotoxy (3,i); cprintf("%s ",op[i]); } piso_color (WHITE,BLACK); gotoxy (3,1); cprintf("%s",op[1]); gotoxy (3,1); } void menu2() { int sw; char c; sw=0; piso_color(BLACK,WHITE); escribe_menu3(); c = getch(); while ((c !=27)&&(sw!=1)) { switch (c) { case 80 : { piso_color (BLACK,WHITE); cprintf("%s",op2[wherey()]); piso_color (WHITE,BLACK); if (wherey() == 6) gotoxy (3,1); else gotoxy (3,wherey()+1); cprintf ("%s",op2[wherey()]); gotoxy (3,wherey()); break; } case 72 : { piso_color(BLACK,WHITE); cprintf("%s",op2[wherey()]); piso_color (WHITE,BLACK); if (wherey() == 1) gotoxy (3,6); else gotoxy (3,wherey()-1); cprintf("%s",op2[wherey()]); gotoxy (3,wherey()); break; } } c=getch(); if(c==13) { switch(wherey()) { case 1:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); ordenar(); mostrar();

clrscr(); escribe_menu3(); getch(); break; } case 2:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); ordenar(); mujeres_ganaron(); clrscr(); escribe_menu3(); getch(); break; } case 3:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); ordenar(); hombres_ganaron(); clrscr(); escribe_menu3(); getch(); break; } case 4:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); ordenar(); alumnos_perdieron(); clrscr(); escribe_menu3(); getch(); break; } case 5:{ piso_color(BLACK,WHITE); window(1,1,80,25); clrscr(); escribe_menu2(); ordenar(); prom_mayor_trescinco(); clrscr(); escribe_menu3(); getch(); break; } case 6:{ sw=1; break; }

} } } } void escribe_menu3() { int i; marco2(16,3,47,8); piso_color(BLACK,WHITE); for(i=2;i<=6;i++) { gotoxy (3,i); cprintf("%s ",op2[i]); } piso_color (WHITE,BLACK); gotoxy (3,1); cprintf("%s",op2[1]); gotoxy (3,1); } void ayuda() { piso_color(BLACK,WHITE); marco2(35,3,65,12); cprintf("%c Desplazamiento hacia arriba ",24); cprintf("%c Desplazamiento hacia abajo ",25); cprintf("%c Desplazamiento a la izquierda",27); cprintf("-> Desplazamiento a la derecha "); cprintf("ENTER para entrar a los menus. "); cprintf("colgantes. "); cprintf("ENTER en cada opcion ingresa a "); cprintf("el desarrollo de esta. "); cprintf("ESC para salir de cada menu. "); getch(); } void salir() { char salida; piso_color(BLACK,WHITE); marco2(58,3,77,3); gotoxy(1,1); cprintf("Desea salir (Y/N):"); salida=getche(); salida=toupper(salida); if(salida=='Y') sw2=1; else if(salida=='N') sw2=0; } void prom_mayor_trescinco() { struct alumno *auxalum2; struct notas *auxnota1,*auxnota2,*auxnotas;

int j,c,st; float prom; j=0; c=2;st=1; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); } else { printf("CODIGO NOMBRE APELLIDO SEXO NT1 NT2 NT3 NT4 DEF\n"); auxalum2=ptr; while(auxalum2!=NULL) { sw=1; auxnota2=auxalum2->ady; while(auxnota2!=NULL) { auxnotas=auxnota2; auxnota2=auxnota2->sig; } if(auxnotas->nota>3.5) { sw=2; } if(sw==2) { gotoxy(1,c);printf("%s",auxalum2->cod); gotoxy(8,c);printf("%s",auxalum2->nom); gotoxy(18,c);printf("%s",auxalum2->apel); gotoxy(30,c);printf("%c",auxalum2->sex); st=2; auxnota1=auxalum2->ady; j=35; while(auxnota1!=NULL) { gotoxy(j,c);printf("%.2f",auxnota1->nota); auxnota1=auxnota1->sig; j=j+8; } c++; } auxalum2=auxalum2->sig; } if(st==1) { gotoxy(1,2); printf("NO EXISTEN ALUMNOS CON PROMEDIOS MAYOR QUE 3.5"); } } getch(); }

void cargar() { struct alumno *nn1; char opcion; struct notas *nn2,*auxnotas,*auxnot; float prom; do { window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); leer_datos(); nn1==malloc(sizeof(struct alumno)); strcpy(nn1->nom,nombre); strcpy(nn1->apel,apellido); strcpy(nn1->cod,codigo); nn1->sex=sexo; nn1->sig=NULL; nn1->ady=NULL; if(ptr==NULL) { ptr=nn1; auxalumn=ptr; sw=1; con=0; prom=0; for(i=0; i<=4; i++) { nn2==malloc(sizeof(struct notas)); if (i<4) { nn2->nota=la_nota[i]; nn2->sig=NULL; if(auxalumn->ady==NULL) { auxalumn->ady=nn2; } else { auxnotas=auxalumn->ady; while(auxnotas->sig!=NULL) { auxnotas=auxnotas->sig; } auxnotas->sig=nn2; } } else { auxnot=auxalumn->ady; while(auxnot==NULL) { prom=prom + auxnot->nota; auxnot=auxnot->sig; } nn2->nota=prom/4; nn2->sig=NULL; auxnotas=auxalumn->ady; while(auxnotas->sig!=NULL)

{ auxnotas=auxnotas->sig; } auxnotas->sig=nn2; } } } else { auxalumn->sig=nn1; auxalumn=nn1; sw=1; con=0; prom=0; for(i=0; i<=4; i++) { nn2==malloc(sizeof(struct notas)); if (i<4) { nn2->nota=la_nota[i]; nn2->sig=NULL; if(auxalumn->ady==NULL) { auxalumn->ady=nn2; } else { auxnotas=auxalumn->ady; while(auxnotas->sig!=NULL) { auxnotas=auxnotas->sig; } auxnotas->sig=nn2; } } else { auxnot=auxalumn->ady; while(auxnot!=NULL) { prom=prom + auxnot->nota; auxnot=auxnot->sig; } nn2->nota=prom/4; nn2->sig=NULL; auxnotas=auxalumn->ady; while(auxnotas->sig!=NULL) { auxnotas=auxnotas->sig; } auxnotas->sig=nn2; } } } do { clrscr();

printf("DESEA ADICCIONAR OTRO EN LA LISTA (y/n):"); opcion=getche(); opcion=toupper(opcion); } while((opcion!='N')&&(opcion!='Y')); }while((opcion!='N')&&(opcion=='Y')); } void leer_datos() { struct alumno *auxalumn2; int j,ppp,lon,encon,dr[20]; char not[10],valido; sw=1; while(sw==1) { gotoxy(1,1);printf("POR FAVOR DIGITE EL CODIGO:"); scanf("\n");gets(codigo); st=1; lon = strlen(codigo); for( i=0;i<=lon-1; i++) { if(!(isdigit(codigo[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL CODIGO !"); delay(1500); gotoxy(10,10); clreol(); st=2; break; } } if(st==2) { gotoxy(28,1);printf(" "); } else { auxalumn2=ptr; encon=2; while(auxalumn2!=NULL) { if(strcmp(auxalumn2->cod,codigo)==0) { encon=1; } auxalumn2=auxalumn2->sig; } if(encon==1) { gotoxy(10,10);printf("ERROR EL CODIGO YA EXISTE!"); delay(1500); gotoxy(10,10); clreol(); gotoxy(28,1);printf(" ");

} else { sw=2; } } } sw=1; while(sw==1) { gotoxy(28,2); printf(" "); gotoxy(1,2); printf("POR FAVOR DIGITE EL NOMBRE:"); scanf("\n"); gets(nombre); st=1; lon = strlen(nombre); for( i=0;i<=lon-1; i++) { if(!(isalpha(nombre[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL NOMBRE..!"); delay(1500); gotoxy(10,10); clreol(); st=2; break; } } if(st==2) { sw=1; } else { sw=2; } } sw=1; while(sw==1) { gotoxy(30,3); printf(" "); gotoxy(1,3); printf("POR FAVOR DIGITE EL APELLIDO:"); scanf("\n"); gets(apellido); st=1; lon = strlen(apellido); for( i=0;i<=lon-1; i++) { if(!(isalpha(apellido[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL APELLIDO..!"); delay(1500); gotoxy(10,10); clreol(); st=2; break; }

} if(st==2) { sw=1; } else { sw=2; } } sw=1; while(sw==1) { gotoxy(1,4); printf("DIGA CUAL ES EL SEXO SI ES (f/m):"); scanf("%c",&sexo); sexo=toupper(sexo); if((sexo!='F')&&(sexo!='M')) { gotoxy(10,10);printf("ERROR AL DIGITAR EL SEXO..!"); delay(700); gotoxy(10,10); clreol(); gotoxy(33,4); printf(" "); } else { sw=2; } } do { valido='n'; j=0; gotoxy(22,5); printf(" "); gotoxy(1,5);printf("ESCRIBA PRIMERA NOTA:"); scanf("\n"); gets(not); lon = strlen(not); st=1; for(i=0;i<=lon-1; i++) { if(st==1) { if(not[i]=='.') { i=i+1; st=2; } } if(!(isdigit(not[i]))) { valido='m'; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol();

break; } } la_nota[j]=atof(not); if((la_nota[j]<0)||(la_nota[j]>5)) { valido='m'; gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } }while(valido=='m'); do { valido='n'; j=1; gotoxy(22,6); printf(" "); gotoxy(1,6);printf("ESCRIBA SEGUNDA NOTA:"); scanf("\n"); gets(not); lon = strlen(not); st=1; for(i=0;i<=lon-1; i++) { if(st==1) { if(not[i]=='.') { i=i+1; st=2; } } if(!(isdigit(not[i]))) { valido='m'; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); break; } } la_nota[j]=atof(not); if((la_nota[j]<0)||(la_nota[j]>5)) { valido='m'; gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } }while(valido=='m');

do { valido='n'; j=2; gotoxy(22,7); printf(" "); gotoxy(1,7);printf("ESCRIBA TERCERA NOTA:"); scanf("\n"); gets(not); lon = strlen(not); st=1; for(i=0;i<=lon-1; i++) { if(st==1) { if(not[i]=='.') { i=i+1; st=2; } } if(!(isdigit(not[i]))) { valido='m'; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); break; } } la_nota[j]=atof(not); if((la_nota[j]<0)||(la_nota[j]>5)) { valido='m'; gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } }while(valido=='m'); do { valido='n'; j=3; gotoxy(21,8); printf(" "); gotoxy(1,8);printf("ESCRIBA CUARTA NOTA:"); scanf("\n"); gets(not); lon = strlen(not); st=1; for(i=0;i<=lon-1; i++) { if(st==1) {

if(not[i]=='.') { i=i+1; st=2; } } if(!(isdigit(not[i]))) { valido='m'; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); break; } } la_nota[j]=atof(not); if((la_nota[j]<0)||(la_nota[j]>5)) { valido='m'; gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } }while(valido=='m'); } void mostrar() { struct alumno *auxalum2; struct notas *auxnota2; auxalum2=ptr; sw=1; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); } else { printf("COD NOMB APELL SEX NOT4 DEF\n"); i=2; textcolor(WHITE); if(auxalum2==NULL) { sw=2; } while(auxalum2==NULL)

NOT1

NOT2

NOT3

{ gotoxy(1,i); printf("%s",auxalum2->cod); gotoxy(11,i); printf("%s",auxalum2->nom); gotoxy(24,i); printf("%s",auxalum2->apel); gotoxy(38,i); printf("%c",auxalum2->sex); auxnota2=auxalum2->ady; c=45; while(auxnota2=NULL) { gotoxy(c,i); printf("%.2f",auxnota2->nota); c=c+6; auxnota2=auxnota2->sig; } auxalum2=auxalum2->sig; i++; } if(sw==2) { clrscr(); printf("NO EXISTE INFORMACION DE ALUMNOS"); } } getch(); } void consulta_codigo() { struct alumno *auxalum2; struct notas *auxnota2; int lon,encon; do { encon=1; auxalum2=ptr; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); getch(); } else { while(encon==1) { st=1; gotoxy(1,1); printf("DIGITE EL CODIGO QUE DESEA CONSULTAR:");

scanf("\n"); gets(codigo); lon = strlen(codigo); for( i=0;i<=lon-1; i++) { if(!(isdigit(codigo[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL CODIGO !"); delay(1500); gotoxy(10,10); clreol(); st=2; break; } } if(st==1) { encon=2; } else { gotoxy(38,1);printf(" "); } } sw=1; i=2; while(auxalum2==NULL) { if(strcmp(codigo,auxalum2->cod)==0) { sw=2; clrscr(); printf("COD NOMB APELL NOT4 DEF\n"); gotoxy(1,i); printf("%s",auxalum2->cod); gotoxy(11,i); printf("%s",auxalum2->nom); gotoxy(24,i); printf("%s",auxalum2->apel); gotoxy(38,i); printf("%c",auxalum2->sex); c=46; auxnota2=auxalum2->ady; while(auxnota2==NULL) { gotoxy(c,i); printf("%.2f",auxnota2->nota); auxnota2=auxnota2->sig; c=c+6; } } auxalum2=auxalum2->sig; } if(sw==1) { clrscr(); printf("VERIFIQUE BIEN SU CODIGO QUE NO EXISTE EN LISTA\n"); getch();

SEX

NOT1

NOT2

NOT3

} else { getch(); } } do { clrscr(); printf("DESEA CONTINUAR, DIGITE (y/n):"); opcion=toupper(getch()); }while((opcion!='Y')&&(opcion!='N')); }while((opcion!='N')&&(opcion=='Y')); } void modificar() { struct notas *auxnotas,*auxnota1,*auxnota2; struct alumno *auxalum2; int j,lon,suma,encon,enc,con; float fl,auxnot,tt,prom; int cc,ppp; char not[5],au,op1,op2,op3,auxi[40]; do { encon=1; auxalum2=ptr; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); getch(); } else { while(encon==1) { st=1; gotoxy(1,1); printf("DIGITE EL CODIGO QUE DESEA MODIFICAR:"); scanf("\n"); gets(codigo); lon = strlen(codigo); for( i=0;i<=lon-1; i++) { if(!(isdigit(codigo[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL CODIGO !"); delay(1500); gotoxy(10,10); clreol(); st=2; break; } }

if(st==1) { encon=2; } else { gotoxy(38,1);printf(" } } sw=1; st=1; while(auxalum2==NULL) {

");

if(strcmp(codigo,auxalum2->cod)==0) { sw=2; do { clrscr(); gotoxy(2,3);printf("1: DATOS DEL ESTUDIANTE"); gotoxy(28,3);printf("2: NOTAS DEL ESTUDIANTE"); gotoxy(55,3);printf("3: SALIR"); gotoxy(2,4);printf("ESCOJA OPCION:");scanf("%c",&op1); if(op1=='1') { do { clrscr(); gotoxy(2,3); printf("1: NOMBRE"); gotoxy(15,3);printf("2: APELLIDOS"); gotoxy(30,3);printf("3: SEXO"); gotoxy(2,4);printf("ESCOJA OPCION:");scanf("%c",&op2); if(op2=='1') { gotoxy(2,5); printf("DIGITE NOMBRE :");scanf("\n"); gets(auxi); strcpy(auxalum2->nom,auxi); } if(op2=='2') { gotoxy(2,5); printf("DIGITE APELLIDOS:");scanf("\n");gets(auxi); strcpy(auxalum2->apel,auxi); } if(op2=='3') { gotoxy(2,5); printf("DIGITE SEXO (f/m):");scanf("\n");scanf("%c",&au); au=toupper(au); while((au!='F')&&(au!='M')) { gotoxy(20,5); printf(" "); printf("DIGITE SEXO (f/m):");scanf("\n");scanf("%c",&au); au=toupper(au); } auxalum2->sex=au;

} }while((op2!='1')&&(op2!='2')&&(op2!='3')); } if (op1=='2') { ppp=1; while(ppp==1) { clrscr(); gotoxy(32,1); printf(" "); gotoxy(1,1); printf("DIGITE NOTA A MODIFICAR [1..4]:"); scanf("\n");gets(not); st=1; lon = strlen(not); for( i=0;i<=lon-1; i++) { if(!(isdigit(not[i]))) { gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); st=2; break; } } if(st==1) { cc=atoi(not); if((cc<1)||(cc>4)) { gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } else { i=2; clrscr(); printf("COD NOMB APELL SEX NOT4 DEF\n"); gotoxy(1,i); printf("%s",auxalum2->cod); gotoxy(11,i); printf("%s",auxalum2->nom); gotoxy(24,i); printf("%s",auxalum2->apel); gotoxy(38,i); printf("%c",auxalum2->sex); c=46; auxnota2=auxalum2->ady; while(auxnota2!=NULL) { gotoxy(c,i);

NOT1

NOT2

NOT3

printf("%.2f",auxnota2->nota); auxnota2=auxnota2->sig; c=c+6; } if(cc==1) { ppp=1; while(ppp==1) { j=0; gotoxy(45,2); printf(" "); gotoxy(46,2); scanf("\n");gets(not); la_nota[j]=atof(not); if(la_nota[j]==0) { ppp=1; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); } else { if((la_nota[j]<0)||(la_nota[j]>5)) { gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } else { con=1; auxnotas=auxalum2->ady; while(con<cc) { auxnotas=auxnotas->sig; con++; } auxnotas->nota=la_nota[j]; ppp=2; } } } } if(cc==2) { ppp=1; while(ppp==1) { j=1; gotoxy(50,2); printf(" "); gotoxy(51,2); scanf("\n");gets(not);

la_nota[j]=atof(not); if(la_nota[j]==0) { ppp=1; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); } else { if((la_nota[j]<0)||(la_nota[j]>5)) { gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } else { con=1; auxnotas=auxalum2->ady; while(con<cc) { auxnotas=auxnotas->sig; con++; } auxnotas->nota=la_nota[j]; ppp=2; } } } } if(cc==3) { ppp=1; while(ppp==1) { j=2; gotoxy(56,2); printf(" "); gotoxy(57,2); scanf("\n");gets(not); la_nota[j]=atof(not); if(la_nota[j]==0) { ppp=1; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); } else { if((la_nota[j]<0)||(la_nota[j]>5)) {

gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } else { con=1; auxnotas=auxalum2->ady; while(con<cc) { auxnotas=auxnotas->sig; con++; } auxnotas->nota=la_nota[j]; ppp=2; } } } } if(cc==4) { ppp=1; while(ppp==1) { j=3; gotoxy(63,2); printf(" "); gotoxy(64,2); scanf("\n");gets(not); la_nota[j]=atof(not); if(la_nota[j]==0) { ppp=1; gotoxy(10,10);printf("NOTA INEXISTENTE... !"); delay(1500); gotoxy(10,10); clreol(); } else { if((la_nota[j]<0)||(la_nota[j]>5)) { gotoxy(10,10);printf("NOTA FUERA DE RANGO... !"); delay(1500); gotoxy(10,10); clreol(); } else { con=1; auxnotas=auxalum2->ady; while(con<cc) { auxnotas=auxnotas->sig; con++;

} auxnotas->nota=la_nota[j]; ppp=2; } } } } auxnotas=auxalum2->ady; con=0; prom=0; while(con<4) { prom=prom+auxnotas->nota; auxnotas=auxnotas->sig; con++; } prom=prom/4; auxnotas=auxalum2->ady; while(auxnotas->sig!=NULL) { auxnotas=auxnotas->sig; } auxnotas->nota=prom; } } } } }while((op1!='1')&&(op1!='2')&&(op1!='3')); } auxalum2=auxalum2->sig; } if(sw==1) { clrscr(); printf("NO EXISTE ESTE CODIGO EN LISTA"); getch(); } } do { clrscr(); printf("DESEA CONTINUAR, DIGITE (y/n):"); opcion=toupper(getch()); } while((opcion!='Y')&&(opcion!='N')); } while((opcion!='N')&&(opcion=='Y')); } void ordenar() { float aux_de_nota[5]; struct alumno *auxalum2,*auxalum3; struct notas *auxnotas,*auxnota2; int i,j; for(i=n-1;i>=1;i--) { auxalum2=ptr; auxalum3=auxalum2->sig;

for(j=1;j<=i;j++) { auxalum2=auxalum2; auxalum3=auxalum3; if(strcmp(auxalum2->cod,auxalum3->cod)>0) { strcpy(codigo,auxalum2->cod); strcpy(nombre,auxalum2->nom); strcpy(apellido,auxalum2->apel); sexo=auxalum2->sex; auxnotas=auxalum2->ady; while(auxnotas!=NULL) { for(i=1; i<=5; i++) { aux_de_nota[i]=auxnotas->nota; } auxnotas=auxnotas->sig; } strcpy(auxalum2->cod,auxalum3->cod); strcpy(auxalum2->nom,auxalum3->nom); strcpy(auxalum2->apel,auxalum3->apel); auxalum2->sex=auxalum3->sex; auxnota2=auxalum3->ady; auxnotas=auxalum2->ady; while((auxnota2->sig!=NULL)&&(auxnotas->sig!=NULL)) { auxnotas->nota=auxnota2->nota; auxnotas=auxnotas->sig; auxnota2=auxnota2->sig; } strcpy(auxalum3->cod,codigo); strcpy(auxalum3->nom,nombre); strcpy(auxalum3->apel,apellido); auxalum3->sex=sexo; auxnota2=auxalum3->ady; i=1; while(auxnota2->sig!=NULL) { auxnota2->nota=aux_de_nota[i]; auxnota2=auxnota2->sig; } } auxalum2=auxalum2->sig; auxalum3=auxalum2->sig; } } } void mujeres_ganaron() { int j; struct alumno *auxalum2; struct notas *auxnotas,*auxnota2,*auxn1; auxalum2=ptr; sw=1; window(3,3,78,22); piso_color(BLACK,WHITE);

clrscr(); textcolor(WHITE); c=2; if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); } else { cprintf("COD NOMBRE APELLIDO SEXO NOT 1 NOT 4 DEF\n"); while(auxalum2!=NULL) { auxnotas=auxalum2->ady; while(auxnotas->sig!=NULL) { auxn1=auxnotas; auxnotas=auxnotas->sig; } if((auxn1->nota>=3)&&(auxalum2->sex=='F')) { sw=2; textcolor(WHITE); gotoxy(1,c); printf("%s",auxalum2->cod); gotoxy(8,c); printf("%s",auxalum2->nom); gotoxy(18,c); printf("%s",auxalum2->apel); gotoxy(30,c); printf("%c",auxalum2->sex); j=37; auxnota2=auxalum2->ady; while(auxnota2!=NULL) { gotoxy(j,c); printf("%.2f",auxnota2->nota); auxnota2=auxnota2->sig; j=j+7; } } c++; auxalum2=auxalum2->sig; } if(sw==1) { clrscr(); printf("NO HAY MUJERES QUE GANARON LA MATERIA"); } } getch(); } void alumnos_perdieron()

NOT 2

NOT 3

{ struct alumno *auxalum2; struct notas *auxnotas,*auxnota2,*auxn1; int j; auxalum2=ptr; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); textcolor(WHITE); c=2; sw=1; if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); } else { cprintf("COD NOMBRE APELLIDO SEXO NOT 1 NOT 4 DEF\n"); while(auxalum2!=NULL) { auxnotas=auxalum2->ady; while(auxnotas!=NULL) { auxn1=auxnotas; auxnotas=auxnotas->sig; } if(auxn1->nota<3) { sw=2; textcolor(WHITE); gotoxy(1,c); printf("%s",auxalum2->cod); gotoxy(8,c); printf("%s",auxalum2->nom); gotoxy(18,c); printf("%s",auxalum2->apel); gotoxy(30,c); printf("%c",auxalum2->sex); j=37; auxnota2=auxalum2->ady; while(auxnota2!=NULL) { gotoxy(j,c); printf("%.2f",auxnota2->nota); auxnota2=auxnota2->sig; j=j+7; } c++; } auxalum2=auxalum2->sig; } if(sw==1) { clrscr(); printf("NO HAY ALUMNOS QUE PERDIERON LA MATERIA");

NOT 2

NOT 3

} } getch(); } void hombres_ganaron() { int j; struct alumno *auxalum2; struct notas *auxnotas,*auxnota2,*auxn1; auxalum2=ptr; window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); textcolor(WHITE); c=2; if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); } else { cprintf("COD NOMBRE APELLIDO SEXO NOT 1 NOT 4 DEF\n"); while(auxalum2!=NULL) { auxnotas=auxalum2->ady; while(auxnotas!=NULL) { auxn1=auxnotas; auxnotas=auxnotas->sig; } if((auxn1->nota>3)&&(auxalum2->sex=='M')) { sw=2; textcolor(WHITE); gotoxy(1,c); printf("%s",auxalum2->cod); gotoxy(8,c); printf("%s",auxalum2->nom); gotoxy(18,c); printf("%s",auxalum2->apel); gotoxy(30,c); printf("%c",auxalum2->sex); j=36; auxnota2=auxalum2->ady; while(auxnota2!=NULL) { gotoxy(j,c); printf("%.2f",auxnota2->nota); auxnota2=auxnota2->sig; j=j+6; } i++; }

NOT 2

NOT 3

auxalum2=auxalum2->sig; } if(sw==1) { clrscr(); printf("NO HAY HOMBRES QUE GANARON LA MATERIA"); } } getch(); } void borrar() { struct alumno *auxalum2,*auxp,*auxalum3; struct notas *auxnotas,*auxnota2; int lon,encon,j; st=1; do { window(3,3,78,22); piso_color(BLACK,WHITE); clrscr(); if(ptr==NULL) { clrscr(); printf("NO EXISTE INFORMACION EN LA LISTA..!"); getch(); } else { encon=1; while(encon==1) { gotoxy(1,1); printf("DIGA CUAL ES EL CODIGO QUE DESEA BORRAR:"); scanf("\n"); gets(codigo); encon=1; lon = strlen(codigo); for( i=0;i<=lon-1; i++) { if(!(isdigit(codigo[i]))) { gotoxy(10,10);printf("ERROR AL DIGITAR EL CODIGO !"); delay(1500); gotoxy(10,10); clreol(); encon=3; break; } } if(encon==3) { encon=1; gotoxy(41,1);printf(" } else

");

{ encon=2; } } auxalum2=ptr; auxalum3=ptr->sig; if( (strcmp(ptr->cod,codigo)==0)) { st=2; ptr=auxalum3; auxnota2=auxalum2->ady; auxnotas=auxalum2->ady; while(auxnota2==NULL) { auxnota2=auxnota2->sig; free(auxnotas); auxnotas=auxnota2; } free(auxalum2); clrscr(); printf("ESTUDIANTE ELIMINADO DE LA LISTA...\n"); getch(); } else { while(auxalum3==NULL) { if(strcmp(codigo,auxalum3->cod)==0) { st=2; auxp=ptr; while(auxp==NULL) { if(auxp->sig==auxalum3) { if(auxp->sig==auxalumn) { auxalumn=auxp; } auxp->sig=auxalum3->sig; auxnotas=auxalum3->ady; auxnota2=auxalum3->ady; while(auxnota2==NULL) { auxnota2=auxnota2->sig; free(auxnotas); auxnotas=auxnota2; } free(auxalum3); clrscr(); printf("YA EL ESTUDIANTE FUE ELIMINADO...\n"); } auxp=auxp->sig; } } auxalum3=auxalum3->sig;

} } if(st==1) { clrscr(); printf("EL CODIGO NO EXISTE EN LISTA"); getch(); } } do { clrscr(); printf("DESEA CONTINUAR, DIGITE (y/n):"); opcion=getche(); opcion=toupper(opcion); } while((opcion!='Y')&&(opcion!='N')); } while((opcion!='N')&&(opcion=='Y')); } void main() { char d; clave(); escribe_menu2(); sw2=0; d=getch(); gotoxy(8,1); while ((d!=27)&&(sw2!=1)) { switch(d) { case 77:{ switch(wherex()) { case 8:{ ref1(8,WHITE,BLACK,"Estudiante"); ref2(26,3,BLACK,"Listados"); break; } case 26:{ ref1(26,WHITE,BLACK,"Listados"); ref2(46,3,BLACK,"Ayuda"); break; } case 46:{ ref1(46,WHITE,BLACK,"Ayuda"); ref2(63,3,BLACK,"Salir"); break; } case 63:{ ref1(63,WHITE,BLACK,"Salir"); ref2(8,3,BLACK,"Estudiante"); break; }

} break; } case 75:{ switch(wherex()) { case 8:{ ref1(8,WHITE,BLACK,"Estudiante"); ref2(63,3,BLACK,"Salir"); break; } case 26:{ ref1(26,WHITE,BLACK,"Listados"); ref2(8,3,BLACK,"Estudiante"); break; } case 46:{ ref1(46,WHITE,BLACK,"Ayuda"); ref2(26,3,BLACK,"Listados"); break; } case 63:{ ref1(63,WHITE,BLACK,"Salir"); ref2(46,3,BLACK,"Ayuda"); break; } } break; } } d=getch(); if(d==13) { switch(wherex()) { case 8:{ menu1(); window(1,1,80,25); clrscr(); escribe_menu2(); break; } case 26:{ menu2(); window(1,1,80,25); clrscr(); escribe_menu2(); break; } case 46:{ ayuda(); window(1,1,80,25); clrscr(); escribe_menu2(); break; } case 63:{

salir(); window(1,1,80,25); clrscr(); escribe_menu2(); break; } } } } }

Programa que muestra como se crear una lista ligada e introduce valores el usuario y tambin se pueden eliminar elementos de la lista ligada

#include<stdio.h> #include<stdlib.h> #include<math.h> #include<dos.h> #include<conio.h> #include<string.h> #include<ctype.h> struct lista { int n; struct lista *sig; }*ptr=NULL,*nn,*p,*pp; int num,numero,sw; void void void void menu2(),menu(); marco(int x1,int y1,int x2,int y2); adic_1(),adic_2(),adic_3(),adic_4(); eliminar();

void visualizar(); void main() { menu(); }

void menu2() { char op; do { window(1,1,80,25); clrscr(); marco(5,3,75,22); marco(10,5,70,20); marco(12,6,68,19); gotoxy(35,7);printf(" MENU 2"); gotoxy(15,9);printf("1. Al principio"); gotoxy(15,10);printf("2. Al final"); gotoxy(15,11);printf("3. Despues de..."); gotoxy(15,12);printf("4. Antes de..."); gotoxy(15,13);printf("5. Regresar"); gotoxy(22,15);printf("digite su opcion: [ ]" ); do { window(41,15,41,15);clreol(); op=getch(); }while((op>'5') ||(op<'1')); window(12,6,68,19); switch(op) { case'1':{ adic_1(); break; } case'2':{ adic_2(); break; } case'3':{ adic_3(); break; } case'4':{ adic_4(); break; } } }while(op!='5'); } void menu() { char op; do { window(1,1,80,25); clrscr(); marco(5,3,75,22); marco(10,5,70,20); marco(12,6,68,19); gotoxy(35,7);printf(" MENU "); gotoxy(15,9);printf("1.INTRODUCIR"); gotoxy(15,10);printf("2.VISUALIZAR"); gotoxy(15,11);printf("3.ELIMINAR"); gotoxy(15,12);printf("4.SALIR"); gotoxy(22,14);printf("digite su opcion: [ ]" ); do { window(41,14,41,14);clreol(); op=getch(); }while((op>'4') ||(op<'1')); window(12,6,68,19); switch(op) { case'1':{ menu2(); break; }

case'2':{ visualizar(); break; } case'3':{ eliminar(); break; } } }while(op!='4'); }

void marco(int x1,int y1,int x2,int y2) { int i; gotoxy(x1, y1); printf("%c",218); // gotoxy(x2, y1); printf("%c",191); // gotoxy(x1, y2); printf("%c",192); // gotoxy(x2, y2); printf("%c",217); // for(i=(x1+1);i<=(x2-1);i++){ gotoxy(i, y1);printf("%c",196);// gotoxy(i, y2);printf("%c",196);} for(i=(y1+1);i<=(y2-1);i++){ gotoxy(x1, i);printf("%c",179); // gotoxy(x2, i);printf("%c",179);} } /****************************************************************/ void adic_1() { clrscr(); printf("Digite un Numero: "); scanf("%d",&num); nn=new lista; nn->n=num; nn->sig=NULL; if(ptr==NULL) ptr=nn; else { nn->sig=ptr; ptr=nn; } printf("Numero insertado por el principio."); getche(); } void adic_2() { clrscr(); printf("Digite un Numero: "); scanf("%d",&num); nn=new lista; nn->n=num; nn->sig=NULL; if(ptr==NULL) ptr=nn; else { p=ptr; while(p->sig!=NULL) p=p->sig; p->sig=nn; } printf("Numero insertado por el final.");

getche(); }

void adic_3() { clrscr(); printf("Digite el numero despues de: "); scanf("%d",&num); p=ptr; sw=0; while(p!=NULL) { if(p->n==num) { sw=1; break; } p=p->sig; } if(sw==0) printf("\nEl elemento no existe"); else { printf("Digite un Numero: "); scanf("%d",&numero); nn=new lista; nn->n=numero; nn->sig=p->sig; p->sig=nn; printf("\nNumero insertado despues de %d",num); } getche(); } void adic_4() { clrscr(); printf("Digite el numero antes de: "); scanf("%d",&num); p=ptr; sw=0; while(p!=NULL) { if(p->n==num) { sw=1; break; } pp=p; p=p->sig; } if(sw==0) printf("\nEl elemento no existe"); else { printf("Digite un Numero: "); scanf("%d",&numero); nn=new lista; nn->n=numero; nn->sig=pp->sig; pp->sig=nn; printf("\nNumero insertado antes de %d",num); } getche(); } void eliminar() { clrscr(); printf("Digite un numero: ");

scanf("%d",&num); p=ptr; sw=0; while(p!=NULL) { if(p->n==num) { sw=1; break; } pp=p; p=p->sig; } if(sw==0) printf("\nEl elemento no existe"); else { pp->sig=p->sig; p->sig=NULL; free(p); printf("\nNumero Eliminado"); } getche(); } void visualizar() { clrscr(); if(ptr==NULL) printf("La lista esta Vacia"); else { p=ptr; while(p!=NULL) { printf(" %d",p->n); p=p->sig; } } printf("\nVisualizacion Completada"); getche(); }

Programa que inserta , elimina y crear elementos en una lista ligada y posteriormente pide al usuario especificar en que posicin de la lista quiere insertar otro elemento

#include "stdio.h" #include "conio.h" #include "stdlib.h" void lis(void); void crea(void);

void inser(void); void elimi(); void hechopor(); void cuadro(int x1, int y1, int x2, int y2); #define memoria (nodo *)malloc(sizeof(nodo)) typedef struct lista nodo; struct lista { int info; nodo *sig,*ant; }; char rr='S'; int dat,sw,opc,op1,op2,aux,o4,con; nodo *cab,*p,*q,*r; void main () {/*cuerpo programa*/ hechopor(); cab=NULL; do {clrscr(); printf("\n"); printf("1: CREAR \n"); printf("2: INSERTAR \n"); printf("3: ELIMINA \n"); printf("4: SALIR \n"); printf("seleccione opcion "); scanf("%d",&opc); switch(opc) { case 1: {crea(); break;} case 2: {inser(); break;} case 3: { elimi(); break;} } } while (opc!=4); } /*final programa*/ void inser(void) { do {clrscr(); printf("1: DESPUES "); printf("2: ANTES "); printf("3: COMIENZO "); printf("4: FINAL "); printf("5: SALIR \n"); printf("Digite opcion\t"); scanf("%d",&op1); switch(op1) { case 1:{ if (cab==NULL) {printf("No existe lista creada presione <enter> ");

rr=getch();} else { do { clrscr(); lis(); printf("\n\ndespues de cual elemento\t"); scanf("%d",&dat); /*busqueda*/ r=cab; sw=0; while ((sw==0) && (r!=NULL)) { if (dat==r->info) sw=1; else r=r->sig; } if (sw==0) printf("no existe el elemento !!!"); else { if ((r==cab) && (r->sig==NULL)) { printf("\nimposible insertar otro elemento "); rr='N'; } else { if (r->sig==NULL) printf("\nno existe un elemento despues para poder insertar el nuevo nodo\n"); else { p=memoria; printf("\n\ndigite el elemento a insertar\t"); scanf("%d",&dat); q=r->sig; r->sig=p; q->ant=p; p->sig=q; p->ant=r; p->info=dat; lis(); } } } printf("\ndesea insertar otro elemento despues s/n\t"); scanf("%s",&rr); } while ((rr=='S') || (rr=='s')); } break; } case 2: { if (cab==NULL)

{printf("No existe lista creada presione <enter> "); rr=getch();} else { do { lis(); printf("\n\nantes de cual elemento a insertar\t"); scanf("%d",&dat); r=cab; sw=0; while ((sw==0) && (r != NULL)) { if (dat==r->info) sw=1; else r=r->sig; } if (sw==0) printf("no existe el elemento !!!"); else { if (r==cab) printf("no existe un elemento antes para poder insertar el nuevo nodo\n"); else { p=memoria; printf("\n\ndigite el elemento a insertar\t"); scanf("%d",&dat); q=r->ant; q->sig=p; r->ant=p; p->sig=r; p->ant=q; p->info=dat; lis(); } } printf("\ndesea seguir insertando otro elemento antes s/n\t"); scanf("%s",&rr); } while ((rr=='S') || (rr=='s')); } break; } case 3: {int dat,sw; do { /*insertar al comienzo*/ clrscr(); p=memoria; printf("digite un numero\t"); scanf("%d",&dat); if (cab==NULL) { p->sig=NULL; p->ant=NULL; p->info=dat;

cab=p; } else { p->info=dat; p->ant=NULL; p->sig=cab; cab->ant=p; cab=p; } clrscr(); printf("\nla lista de elemento es\n\n"); q=cab; while (q!=NULL) { printf("%d\t",q->info); q=q->sig; } printf("\ndesea seguir adicionando otro nodo s/n\t"); scanf("%s",&rr); } while ((rr=='S') || (rr=='s')); break; } case 4: { /*inserta al final*/ crea();} } } while (op1!=5); } void lis(void) { clrscr(); printf("\nla lista de elemento es\n\n"); q=cab; while (q!=NULL) { printf("%d\t",q->info); q=q->sig; } } void crea(void) { do {clrscr(); p=memoria; printf("digite un numero\t"); scanf("%d",&dat); if (cab==NULL) { p->sig=NULL; p->ant=NULL; p->info=dat; cab=p; } else { q=cab; while (q->sig != NULL)

q=q->sig; p->info=dat; q->sig=p; p->ant=q; p->sig=NULL; } lis(); printf("\ndesea seguir adicionando otro nodo s/n\t"); scanf("%s",&rr); } while ((rr=='S') || (rr=='s')); } void elimi() { int dat,sw; char rr; clrscr(); if (cab==NULL) { printf("\nno existen elementos en la lista !!!! presione <ENTER>"); rr=getch(); } else { do { clrscr(); printf("1: INFORMACION X "); printf("2: DESPUES "); printf("3: ANTES "); printf("4: SALIR \n"); printf("Digite opcion\t"); scanf("%d",&op2); switch(op2) { case 1:{/*informacion X*/ do {clrscr(); lis(); printf("\n\ndigite el elemento a eliminar\t"); scanf("%d",&dat); r=cab; sw=0; while ((sw==0) && (r != NULL)) { if (dat==r->info) sw=1; else r=r->sig; } if (sw==0) printf("no existe el elemento !!!"); else { if ((r==cab) && (r->sig==NULL)) cab=NULL; else { if (r==cab) { p=r->sig; p->ant=NULL; free(cab);

cab=p; } else { if (r->sig==NULL) { p=r->ant; p->sig=NULL; free(r); } else { q=r->ant; p=r->sig; q->sig=p; p->ant=q; free(r); } } } } if (cab!=NULL) { printf("\nla lista de elemento es\n\n"); q=cab; while (q!=NULL) { printf("%d\t",q->info); q=q->sig; } printf("\ndesea seguir eliminando otro elemento s/n\t"); scanf("%s",&rr); } else { printf("\nno existen elementos en la lista !!!! presione <ENTER>"); rr=getch(); rr='N'; } } while ((rr=='S') || (rr=='s')); break; } case 2: { do { clrscr(); lis(); printf("\n\ndigite el elemento a eliminar\t"); scanf("%d",&dat); r=cab; sw=0; while ((sw==0) && (r != NULL)) { if (dat==r->info) sw=1; else r=r->sig; } if (sw==0) printf("no existe el elemento !!!");

else { if (r->sig==NULL) printf("no existe un elemento despues a eliminar\n"); else { p=r->sig; if (p->sig==NULL) { r->sig=NULL; } else { q=p->sig; r->sig=q; q->ant=r; } free(p); } } printf("\nla lista de elemento es\n\n"); q=cab; while (q!=NULL) { printf("%d\t",q->info); q=q->sig; } printf("\ndesea seguir eliminando otro elemento s/n\t"); scanf("%s",&rr); } while ((rr=='S') || (rr=='s')); break; } case 3: { /********************/ do { clrscr(); lis(); printf("\ndigite un numero\t"); scanf("%d",&dat); if (cab==NULL) { printf("no existen elementos en la lista !!! presione <ENTER>"); rr=getch();} else { r=cab; sw=0; while ((sw==0) && (r != NULL)) { if (dat==r->info) sw=1; else r=r->sig; } if (sw==0) { printf("elemento inexistente presione <ENTER>\n"); rr=getch();} else

{ if (r==cab) { printf("no existe un elemento antes a eliminar presione <ENTER>\n"); rr=getch();} else { q=r->ant; if (q==cab) { q->sig=NULL; r->ant=NULL; free(q); cab=r; } else { p=q->ant; p->sig=r; r->ant=p; free(q); } } } } /*******************/ lis(); if (cab!=NULL) { printf("\ndesea seguir eliminando otro elemento s/n\t"); scanf("%s",&rr); } else { printf("\nno existen elementos en la lista !!!! presione <ENTER>"); rr='N'; } } while ((rr=='S') || (rr=='s')); break; } } } while (op2!=4); } } /**************************************/ void hechopor() { textmode(C80); clrscr(); textcolor(3); cuadro(1,1,79,25); cuadro(17,9,64,21); gotoxy(50,3); cprintf("6 de OCT de 1998"); gotoxy(26,10); cprintf(" Estructura de Datos "); gotoxy(19,11); cprintf("Presentado Por: NILSON LAJUD IRIARTE"); textcolor(3+BLINK); gotoxy(27,24); cprintf("Oprima Una Tecla Para Continuar");

textcolor(3); getch(); } void cuadro(int x1, int y1, int x2, int y2) { int i; for(i=x1;i<=x2;i++) { gotoxy(i,y1); cprintf(""); gotoxy(i,y2); cprintf(""); } for(i=y1;i<=y2;i++) { gotoxy(x1,i); cprintf(""); gotoxy(x2,i); cprintf(""); } }