Uso de la estructura C para escribir un sistema de desempeño estudiantil
/* * * * *Archivo de encabezado (.h)* * * * * * * */
#include "stdio.h" /*Función de E/S*/
#include "stdlib.h" /*Otros comentarios*/
#include "string.h" /*Función de cadena*/
#Include "conio. h" /*Función de operación de pantalla*/
#include "mem . h" /*Función de operación de memoria*/
#include "ctype.h" /*Función de operación de caracteres*/
#include "alloc.h" /*Función de asignación dinámica de direcciones */
# define N ^ 3/*Definir constantes*/
Typedef struct z1 /*Definir estructura de datos*/
{
Número de carácter[11];
nombre de carácter[15];
puntuación int[N];
Suma flotante;
Promedio flotante;
int orden;
struct z 1 * next;
}Estudiante;
/*Las siguientes son Funciones prototipo*/
Estudiante* init();/*Función de inicialización*/
Estudiante* create();/*Crear una lista enlazada*/
estudiante * eliminar (estudiante * h); /* eliminar registro */
void print (estudiante * h) /* mostrar todos los registros */
void search (estudiante * h); ; /*Buscar*/
void save(Estudiante* h); /*Guardar*/
Estudiante* cargar() /*Leer registros*/
);void computer(estudiante * h);/*calcular puntaje total y puntaje promedio*/
estudiante * insertar(estudiante * h);/*insertar registro*/
void append();/*Registro adicional*/
Estudiante * sort(estudiante* h); /*Ordenar*/
int menu _ select() /*Función de menú */
/* * * * * *Se inicia la función principal* * * * * *
main()
{
int I;
Estudiante*head;/*Puntero de encabezado de definición de lista vinculada*/
head = init();/*Inicializar lista vinculada*/
clr SCR();/*Borrar la pantalla*/
for(;;)/*Bucle infinito*/
{
Cambiar(menu_select() ) / *Llame a la función del menú principal y devuelva un número entero como condición de la declaración Switch*/
{/*Los valores son diferentes y las funciones ejecutadas también son diferentes.
break no se puede omitir*/
Caso 0: head = init(); break /*Realizar inicialización*/
Caso 1: head = create(); Crear una lista vinculada*/
Caso 2: head=delete (head); /*Eliminar registro*/
Caso 3: print (head); Mostrar todo Registro*/
Caso 4: Buscar (cabecera); /*Buscar registro*/
Caso 5: Guardar (cabecera); /
Caso 6: head = load(); break; /*Leer archivo*/
Caso 7: Computadora (head /*Calcular puntaje total y puntaje promedio); * /
Caso 8: cabeza = insertar(cabeza); /*insertar registro*/
Caso 9: cabeza = ordenar(cabeza/*ordenar*); /
Caso 10: append(); break; /*Registro adicional*/
Caso 11: Salir (0); termina*/
}
}
}
/*Función de menú, el valor de retorno es un número entero*/
menu_select ()
{
char * menú[]= { * * * * * * * * * * * menú * * * * * * * * * * * * * * * * * * * *, /* define la matriz de cadenas del menú */
"0.Initialization list", /* Inicializar */
"1. Lista de entrada", /*Ingresar registros*/
"2. Eliminar registros de la lista", /*Eliminar registros de la tabla*/
"3. , /*Mostrar todos los registros individuales en la lista vinculada*/
"4. Buscar registros por nombre", /*Buscar registros por nombre*/
"5. Guardar archivo" , /*Convertir lista enlazada individualmente Guardar los registros en un archivo*/
"6. Cargar archivo", /*Leer registros del archivo*/
"7. Calcular Score", /*Calcular puntajes totales y promedio de todos los estudiantes*/
"8. Insertar registros en la lista", /*Insertar registros en la tabla*/
"9. para generar un nuevo archivo" , /* Ordenar */
"10. Agregar registros al archivo", /*Agregar registros al archivo*/
" 11. Salir" }; / *Salir* /
char s[3] /*Guardar el número de selección en forma de carácter*/
int c, I /*Definir una variable entera*/
gotoxy(1,25);/*Mover el cursor*/
printf("Presione cualquier tecla para ingresar al menú...\n");/*Presione cualquier tecla para ingresa al menú principal*/
getch() /*Ingresa cualquier clave*/
clr SCR() /*Borrar la pantalla*/
gotoxy(1, 1); /*Mover el cursor*/
textcolor(amarillo); /*Establecer el color de visualización del texto en amarillo*/
textbackground(blue); *Establece el color de fondo en azul Color*/
gotoxy(10, 2 /*Mover el cursor*/
patch(0xc 9); borde de la esquina┏ */
for(I = 1;ilt44;i)
patch(0x CD);/*Emite la línea horizontal del borde superior*/
patch(0x bb);/*Salida Borde de la esquina superior derecha ┓ *
/
for(I = 3; i lt20; i)
{
gotoxy(10, I); putch(0x ba); Línea vertical izquierda*/
gotoxy(54, I); putch(0x ba);
}/*Salida línea vertical derecha*/
gotoxy( 10, 20); putch(0x c8); /*Imprime el borde de la esquina superior izquierda┗ */
for(I = 1; I lt44; i )
patch(0x). CD) ;/*Imprime la línea horizontal del borde inferior*/
patch(0x BC); /*Imprime el borde de la esquina inferior derecha┛ */
Ventana (11, 3, 53, 19); / *Crea una ventana para mostrar el menú. El tamaño de la ventana se diseña según el número de menús*/
clr SCR() /*Borrar la pantalla*/<; /p>
for(I = 0; I lt13;I) /*Salida de matriz del menú principal*/
{
gotoxy(10, I 1);
cprintf("s ",menu [I]);
}
textbackground(negro /*Establece el color de fondo en negro*/
Ventana (1, 1, 80, 25); /*Restaurar el tamaño original de la ventana*/
gotoxy(10, 21); /*Mover el cursor*/
Hacer {
printf(" \nIngrese su elección (0 ~ 14): " /*Mostrar información de solicitud fuera de la ventana del menú*/
scanf("s " , s); /*Ingresar opciones*/
c = atoi(s);/*Convertir la cadena de entrada a un número entero*/
} while(c lt; 0 | | c > 11); /*Elemento seleccionado No entre 0 y 14.
Vuelva a ingresar*/
Volver a c /*Volver a la opción, el programa principal llama a la función correspondiente según el número*/
}
Estudiante *init()
{
Devolver NULL
}
/*Crear una lista enlazada*/
Estudiantes* crear ( )
{
int I; int s;
ESTUDIANTE *h=NULL, *info/*Puntero de estudiante a estructura */
for(;;)
{
info=(estudiante*)malloc(sizeof(estudiante));/*Espacio de aplicación*/
if (!Info) /*Si la información del puntero está vacía*/
{
printf("\nMemoria insuficiente"); */
Devolver NULL/*Devolver puntero nulo*/
}
Entrada ("Ingrese número:", información - gt; No, 11); /*Ingrese el número de estudiante y marque */
if (info- gt; no [0]=='@ ') separator /*Si el primer carácter del número de estudiante es @, la entrada; termina */
Input("Ingrese nombre:", información - gt; nombre, 15 /*Ingrese nombre y verifique*/
printf("Por favor ingrese d puntuación\); n ", N); /*Solicita comenzar a ingresar puntajes*/
s = 0; /*Calcula el puntaje total de cada estudiante, el valor inicial es 0*/
/*N cursos se repiten N veces */
/*Guardar la puntuación total*/
/*Calcular el promedio*/
/**** ******** ******************************************* *****/
/* */
/* */
/* // TODO: agrega tu código aquí* /
/* */
/* */
/************************ *********** ****************************/
Información - gt ; orden = 0; /* antes de ordenar El valor es 0 */
Información - gt; next = h /* Utilice el primer nodo como nodo sucesor del nuevo nodo de entrada */
h = info/*Nueva entrada El nodo es el nuevo nodo principal*/
}
Return (h) /*Devuelve el puntero principal*/
}
/*Ingrese una cadena y verifique su longitud*/
Entrada (char *prompt, char *s, int count)
{
char p[ 255];
Hacer {
printf(prompt); /*Mostrar información de solicitud*/
scanf("s ", p); /*Cadena de entrada*/
if(strlen(p)>count)printf("\n¡Demasiado largo! \n ");/*Compruebe la longitud y vuelva a ingresar*/
} while(strlen(p)>count);
strcpy(s, p);/* Convertir Copiar la cadena de entrada a la cadena s */
}
/*Imprimir la información del nodo en la lista vinculada*/
Deshabilitar la impresión (estudiante *h )
{
int I = 0; /*número de registros estadísticos*/
Estudiantes* p /*mover puntero*/
clr SCR();/*Borrar pantalla*/
p =
h; /*El valor inicial es el puntero principal*/
printf(" \ n \ n \ n * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");
printf(" | rec | nO | nombre | sc 1 | sc2 | sc3 | suma | ave | orden | \ n ");
printf(" |-|-| -|-| -|-|-|-|-|-| \ n ");
Y (p!=null)
{
i;
p>
printf(" | 3d | -10s | -15s | 4d | 4d | 4d | 4.2f | 4.2f | 3d | \n ", I, p- gt; no, p- gt; nombre, p - gt; puntuación[0], p- gt; puntuación[1],
p->; puntuación[2], p- gt; >promedio, p- gt; orden );
p = p- gt; siguiente;
}
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * fin * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
}
/*Eliminar registro*/
Estudiante*Eliminar(Estudiante*h )
{
Estudiante *p, *q;/*p es el puntero de nodo que se eliminará, q es su puntero predecesor*/
char s [11];/*almacenamiento Número de estudiante*/
clr SCR(); /*Borrar la pantalla*/
printf("Por favor eliminar\ n "); solicitar información*/
scanf("s ", s); /*Ingrese el número de estudiante del registro que se eliminará*/
q = p = h; valores iniciales a Q y P*/
/*Cuando el número de estudiante registrado no es el que busca, o el puntero no está vacío*/
/** **************** ********************************** *********/
/* */
/* */
/* // TODO: agrega tu código aquí* /
/* */
/* */
/********************* ******************* ****************************/
If(p==NULL) /*Si p está vacío, entonces el nodo no está en la lista enlazada*/
printf("\nlist no s Student\n ", s) ;
De lo contrario /*p no está vacío, muestra la información del registro encontrado*/
{
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * Encontró * * * * * * * * * * * * *
* * * * * * * * * * * * * \ n ");
printf(" | no | nombre | sc 1 | sc2 | sc3 | suma | ave | orden | \ n ") ;
printf(" |-|-|-|-|-|-|-|-|-| \ n ");
printf(" | -10s | - 15s | 4d | 4d | 4d | 4.2f | 4.2f | 3d ",p- gt; no lo sé,
p->; nombre, p- gt; puntuación [0] , p - gt; puntuación [1], p- gt; puntuación [2], p- gt; suma,
p->; promedio, p- gt; p >printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * fin * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
getch(); /*Presione cualquier tecla para eliminar*/
Si (p==h) /*Si p==h, el nodo eliminado es el nodo principal*/
h = p- gt; Siguiente /*Modifica el puntero principal para que apunte al siguiente registro; */
Otros
q->; next = p- gt; next; /* no es un puntero principal, el nodo sucesor de P se considera el nodo sucesor de Q. */
Gratis (p); /*Libera el espacio del nodo indicado por P*/
printf("\nS estudiantes no fueron eliminados\n ", s);
printf("No olvides guardar\n "); /*No olvides guardar el archivo después de eliminarlo*/
}
Return ( h); /*Devuelve el puntero principal*/
}
/*Buscar registro*/
Búsqueda no válida (estudiante*h)
{
Estudiante * p; /*Mover el puntero*/
char s[15] /*Matriz de caracteres utilizada para almacenar el nombre*/
clr SCR(); /*Borrar la pantalla* /
printf("Ingrese el nombre de búsqueda \ n ");
scanf("s ", s) /*Ingrese el nombre*/
p = h; /*Asigne el puntero principal a p*/
while(strcmp(p- gt; nombre, s) y amp; .
amplificador! =NULL) /*Cuando el nombre del registro no es el nombre que estás buscando, o el puntero no está vacío*/
p = p- gt; siguiente nodo* /
If(p==NULL) /*Si el puntero es nulo*/
printf("\nlist no s Student\n ", s); *No mostrar estudiantes */
Else /*Mostrar la información del registro encontrado*/
{
printf(" \ n \ n * * * * * * * * * * * * * * * * * * * * * * * * * * * * Encontró * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");
printf(" | nO | nombre | sc 1 | sc2 | sc3 | suma | ave | orden | \ n ");
printf(" | -|- |-|-|-|-|-|-|-| \ n ");
printf(" | -10s | -15s | 4d | 4d | 4d | 4.2f | 4.2 f | 3d | \n ", p- gt; no sé,
p->; nombre, p- gt; puntuación [0], p- gt; puntuación [1], p- gt; puntuación [2 ],p-gt;suma,p->promedio,p-gt;orden);
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * fin * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");
}
}
/*Insertar registro*/
Estudiante*insertar (estudiante*h)
{
Estudiantes *p, *q, *información; /*p apunta a la posición de inserción, q es su predecesor, info se refiere al registro recién insertado*/
char s[11 ]; /*Guardar el número de estudiante del punto de inserción*/
int s1, I;
printf("Ingrese la posición antes del número\ n ");
scanf("s ", s);/*Ingrese el número de estudiante del punto de inserción*/
printf("\nPor favor cree un nuevo registro\n ");/*Solicitud para ingresar la información del registro*/
info=(student*)malloc(sizeof(student)); /*Espacio de aplicación*/
If (! Información)
{
printf("\nMemoria insuficiente"); /*Si no se aplica, la memoria se desborda*/
Devuelve NULL/*Devuelve puntero NULL */
}
Entrada ("Ingrese número:", información - gt; No, 11 /*Ingrese número de estudiante*/
Entrada ( "Ingrese el nombre:", información - gt; nombre, 15); /*Ingrese el nombre*/
printf ("Ingrese d puntuación\n ", N /* Solicite ingresar la puntuación*/);
s 1 = 0; /*Guarda la puntuación total del nuevo registro, el valor inicial es 0*/
for(I = 0; Iltn; I) /*N cursos Repita N veces para ingresar la puntuación*/
{
Hacer{ /*Verifique los datos para asegurarse de que estén entre 0 y 100*
/
printf("Puntuación d: ", I 1);
scanf("d ", información del amplificador - gt; puntuación[I]); >if(info- gt; puntuación[I] gt; 100 | | información-> puntuación[I] lt; 0)
printf("Datos incorrectos, entrada repetida\n");
p>} while(info- gt; puntuación[I] gt; 100 | | información->; puntuación[I] lt; 0
s 1 = s 1 info- gt); ; Score[I];/*Calcular puntuación total*/
}
Información - gt;sum = s 1;/*Guardar puntuación total en un nuevo registro*/
Información - gt; promedio = (flotante)s 1/N; /*Calcular puntuación promedio*/
Información - gt; orden = 0 /*Calificar tarea 0*/< /p; >
Información - gt; next = NULL /*Establecer puntero posterior a nulo*/
p = h /*Asignar puntero a p*/
q = h; /*Asigna el puntero a q*/
while(strcmp(p- gt; no, s) amp; ampp!=NULL) /*Encuentra la posición de inserción*/
{
q = p; /*Guardar puntero p como predecesor del siguiente p*/
p = p- gt /*Guardar puntero P Retroceder*/
}
If(p==NULL) /*Si el puntero p es nulo, no se especifica ningún nodo*/
If (p==h) /*Al mismo tiempo, p es igual a h, lo que indica que la lista enlazada está vacía*/
h = info/*El nuevo registro es el nodo principal*/
Otros< /p >
q->; next = info/*p está vacío, pero p no es igual a h.
Insertar un nuevo nodo al final de la tabla*/
Otro
Si (p==h) /*p no está vacío, el nodo especificado*/
{
Información - gt; next = p; /*Si p es igual a h, inserta un nuevo nodo antes del primer nodo*/
h = info/*Nuevo nodo ¿Es el nuevo nodo principal*/
}
Otro
{
Información - gt; next = p; nodo principal, pero en algún punto intermedio, el sucesor del nuevo nodo es p*/
q-> next = info/*El nuevo nodo es el nodo sucesor de Q*/
;}
printf("\n -s estudiantes han sido insertados-\n ", info- gt; nombre); printf("-no olvides guardar-\n "); /*guardar mensaje*/
Return (h); /*Devuelve el puntero principal*/
}
/*Guarda los datos en el archivo* /
Guardado no válido (Estudiante*h)
{
ARCHIVO * fp/*Definir el puntero al archivo*/
Estudiante* p; /*Definir el puntero móvil*/
char outfile[10];/*Guardar el nombre del archivo de salida*/
printf("Ingrese el nombre del archivo de salida, como c:\\f1\\te.txt:\ n "); /*Solicitar información de formato del nombre del archivo*/
scanf("s ", outfile);
If ((FP = fopen (outfile, " WB))= = null)/*Abrir un archivo binario para salida, o crear*/
{
printf("No se puede abrir file\n ");
Salir (1);
}
printf("\nGuardar archivo...\n");/*Abrir el archivo y solicitar guardar*/
p = h /*Aleja el puntero del puntero principal*/
Y (p!=NULL) /*Si p no es null*/
{
fwrite(p, sizeof(estudiante), 1, FP /*escribir registro*/
p = p- gt); ; next; /*mover el puntero hacia atrás*/
}
fclose(FP); /*Cerrar el archivo*/
printf(" -Guardar exitosamente!!-\ n "); /*Pantalla guardada exitosamente*/
}
/*Leer datos del archivo*/
Estudiante*Cargar( )
{
Estudiante *p, *q, *h = NULL/*Definir variable de puntero de registro*/
FILE * fp/*Definir puntero a file*/
char infile[10];/*Guardar nombre de archivo*/
printf("Ingrese el nombre del archivo, como c:\\f1\\te.txt: \n");scanf("s ",infile);/*Ingresar nombre del archivo*/
If ((FP = fopen (infile," Rb))== = null)/*Abrir binario archivo en modo lectura*/
{
printf("No se puede abrir el archivo\n " /*Si no se puede abrir, finalice el programa*/
Salir (1);
}
printf("\n - ¡Cargando archivo! -\ n ");
p=(estudiante*)malloc(tamañode
(Estudiante)); /*Espacio de aplicación*/
If (!p)
{
printf("¡Memoria insuficiente!\n ");/ *Si no se aplica, la memoria se desborda*/
Devuelve h; /*Devuelve puntero nulo*/
}
h = p; Se aplica a espacios*/
while (!Feof(fp)) /*Bucle para leer datos hasta el final del archivo*/
{
If (1 ! =fread(p, sizeof(STUDENT), 1, fp))
Break /*Si los datos no han sido leídos, salta del bucle*/
p ->; next =(student*)malloc(sizeof(student));/*Aplicar espacio para el siguiente nodo*/
If (!p->; next)
{
printf("¡Memoria insuficiente! \ n "); /*Si no hay aplicación, la memoria se desborda*/
Devuelve h;
}
q = p; /*Guardar el puntero del nodo actual como puntero del siguiente nodo*/
p = p- gt /*El puntero se mueve hacia atrás; y se vuelve a leer el enlace de datos Pie de página actual*/
}
q->; next = NULL/*El puntero sucesor del último nodo es null*/
fclose(FP) ;/*Cerrar el archivo*/
printf(" -¡¡¡Has leído correctamente los datos del archivo!!!-\ n ");
Return h; /*Devolver puntero de encabezado*/
}
/*Agregar registros al archivo*/
void append()
{
ARCHIVO * fp/*Definir puntero al archivo*/
Información del estudiante* /*Nuevo puntero de registro*/
int s1, I ;
char infile[10];/*Guardar nombre de archivo*/
printf("\nPor favor, cree un nuevo registro\n");
info =(estudiante*)malloc( tamaño de(estudiante));/*Espacio de aplicación*/
If (! información)
{
printf("\ nMemoria insuficiente");/ *No aplicado, desbordamiento de memoria*/
Regresar;
}
Input("Ingrese número:", mensaje - gt; No, 11);/ *Llame a las entradas para ingresar su número de estudiante*/
Input("Ingrese el nombre:", información - gt; nombre, 15 /*Llame a las entradas para ingresar el nombre*/);
printf("Ingrese d puntuación\n ", N); /*Nivel de solicitud*/
s 1 = 0;
for(I = 0;iltn;i )
{
Hacer {
printf("Puntuación d: ", I 1
scanf); ("d ", amp información-gt;puntuación[I]);/*Ingresar puntuación*/
if(info-gt;puntuación[I] gt;100 | |Información->puntuación[I ]lt;0 )printf("Datos incorrectos, vuelva a ingresar\n");
} while(info- gt; puntaje[I] gt; 100 | | información-> puntaje[I] lt ; 0); /*Verificación de datos de rendimiento*/
s 1 = s 1 info- gt; puntuación /*Obtener puntuación total*/
}
info - gt; suma = s 1;* guardar puntuación total
*/
Información - gt; promedio = (float)s 1/N; /*Calcular la puntuación promedio*/
Información - gt; El valor es 0*/
Información - gt; next = NULL/*Asigne el puntero posterior del nuevo registro a null */
printf("Ingrese el nombre del archivo, como c :\ \ f 1 \\te .txt:\n "); scanf("s", infile); /*Ingrese el nombre del archivo*/
If ((fp = fopen (infile, "ab ))= = null)/*Abra el archivo agregando datos al final del archivo binario*/
{
printf("No se puede abrir el archivo\n "); *La pantalla no se puede abrir* /
Salir (1); /*Salir del programa*/
}
printf("\n -Agregar registro !-\ n ");
If (1!= fwrite (info, sizeof (estudiante), 1, FP))/*Escribir operación de archivo*/
{
printf(" -¡Error al escribir el archivo! -\ n ");
Return /* Return */
}
printf( " -¡Agregar exitosamente!- \ n ");
fclose(FP); /*Cerrar archivo*/
}
/*Ordenar*/
Estudiante*sort(estudiante*h)
{
int I = 0 /*Guardar clasificación*/
Estudiante * p, *q, *t , * h 1; /*Definir puntero temporal*/
h 1 = h- gt Siguiente /*Usar el siguiente nodo señalado por el puntero del encabezado de la tabla original; puntero principal*/
h- gt; next = NULL/*El primer nodo es el nodo principal de la nueva tabla*/
/*Ordenar cuando la tabla original no está vacía */
/ **************************************** *********** *********/
/* */
/* */
/* // TODO: Añade el tuyo aquí Código* /
/* */
/* */
/******** **************** ********************************** ********/
p = h; /*El puntero principal ordenado se asigna a P, listo para completar la clasificación*/
Y (p! =NULL) /*Cuando p no está vacío, realice las siguientes operaciones*/
{
i /*Número de serie del nodo*/
p- >; orden = I; /*Asignar nivel*/
p = p- gt; Siguiente /*Mover el puntero hacia atrás*/
}
printf("¡¡¡Ordenar correctamente!!!\n "); /* Ordenar correctamente*/
Devolver h /*Devolver puntero de cabeza*/
}
< p; >/*Calcular puntuación total y promedio*/Computadora no válida (estudiante*h)
{
Estudiante* p;
int I = 0; /*El valor inicial del número de registros guardados es 0*/
Long s = 0 /*La puntuación total inicial es 0*/<; /p >
Promedio flotante = 0; /*El valor inicial promedio es 0*/
p = h /*Comienza desde el puntero principal*/
>Y (p!=NULL) /*Procesado cuando p no está vacío*/
{
s = p- gt /*Puntuación total acumulada*/< / p>
i; /*El número de registros estadísticos*/
p = p- gt; Siguiente /*El puntero se mueve hacia atrás*/
}
Promedio=(float)s/I;/*Encuentre el puntaje promedio, divídalo en números de punto flotante, el puntaje total es un número entero, escriba conversión*/
printf("\ n -all La puntuación total de los estudiantes es: ld el promedio es 5.2f\n ", s, promedio);
}