Sistema de gestión del desempeño estudiantil (programación en lenguaje C)
/*Archivo de encabezado*/
# incluir ltstdio.h gt
# incluir ltdos.h gt
# incluir ltstdlib. h gt/*Otros comentarios*/
# include ltstring.h gt/*Función de cadena*/
# include ltmem.h gt/*Función de operación de memoria*/
# include ltctype.h gt/*Función de operación de caracteres*/
# include ltalloc.h gt/*Función de asignación dinámica de direcciones*/
#Definir tamaño LEN de ( Estudiante)
Typedef struct stu /*Definir la matriz de estructura utilizada para almacenar en caché los datos*/
{ char num[6];
Nombre del personaje[5] ;
int puntuación[3];
int suma
Promedio flotante
int orden; struct stu * next
}Estudiante;
/*Prototipo de función*/
Estudiante* init();/*Función de inicialización*/
int menu _ select();/*Función de menú*/
Estudiante* create();/*Crear una lista enlazada*/
Desactivar impresión (Avatar de Estudiante* ); /*Mostrar todos los registros*/
búsqueda nula (estudiante * jefe); /*Buscar registro*/
Estudiante * eliminar (estudiante * jefe); */
Estudiante*Ordenar(Estudiante*Cabeza);/*Ordenar*/
Estudiante*Insertar(Estudiante*Cabecera, Estudiante*Nuevo);/*Insertar registro*/
Guardar vacío (estudiante * cabeza); /*guardar archivo*/
estudiante* cargar(); /*leer archivo*/
/* Función principal interfaz*/
Main()
{Estudiante*head, new;
head = init();/*La lista enlazada se inicializa, formando head El valor es NULL*/
for(;;)/*bucle infinito*/
{switch (menu_select())
{
caso 1: cabeza = crear(); romper;
Caso 2: imprimir (cabeza)
Caso 3: buscar (cabeza); p>
Caso 4: head=delete(head);
Caso 5: head=sort(head);
Caso 6: head = insert ( head & new); break /* & new significa dirección de retorno*/
Caso 7: guardar (head break);
Caso 8: head = load(); ;
Caso 9: Salir (0); /*Si el valor de retorno del menú es 9, el programa finaliza*/
}
}
}
/*Función de inicialización*/
Estudiante *init()
{
Regresar NULL/*return puntero nulo*/
}
/*función de selección de menú*/
menu_select()
{ int n ;
Fecha de estructura d; /*Definir estructura de tiempo*/
getdate( amp; d);
*/
printf("Presione cualquier tecla para ingresar al menú...");/*Presione cualquier tecla para ingresar al menú principal*/
getch();/* Lee caracteres del teclado, pero no los muestra en la pantalla*/
clr SCR() /*Borrar la pantalla*/
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("\t\tBienvenido\n ");
printf("\n\t\tEstudiante Sistema de gestión del rendimiento";
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *Menú * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("\ t\t\t1 .Ingresar registro\n "); /*Ingresar registro del estudiante*/
printf("\t\t\t2. Imprimir registro\n "); /*Mostrar*/
printf("\t\t\t3. Buscar registros por nombre\ n "); /*Buscar*/
printf("\t\t\t4. Eliminar un registro \ n "); /*Delete*/
printf("\t\t\t5. Ordenar para crear un nuevo archivo\n "); /*Sort*/
printf ("\t\ t\t6. Insertar el registro en la lista\ n "); /*Insert*/
printf("\t\t\t7. Guardar el archivo\ n "); /*Guardar*/
printf("\t\t\t8.Cargar archivo\n");/*Leer*/
printf("\t\t\t9 .Salir\n");/ *Salir*/
printf("\n\t\tProducido por Hu Haihong.\n ");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("\t\t\t\td\\d\\d\n ", d.da_year, d .da_mon, d . da _ day ); /*Mostrar la fecha actual del sistema*/
Haga {
printf("\n\t\t\tIngrese su selección (1 ~9):");
scanf("d ", ampn);
} while(n lt; 1 | | n > 9); /*Si el elemento seleccionado no está entre 1 y 9, ingrese nuevamente*/
Return (n); /*Devuelve el elemento seleccionado, la función principal llama a la función correspondiente según el número*/
}
/*Función de entrada*/
Estudiante *Crear()
{int i, s
Estudiante *head; =NULL, * p; /*Función de definición.
Esta función devuelve un puntero al encabezado de la lista enlazada*/
clr SCR();
for(;;)
{ p = (ESTUDIANTE *)malloc (LEN); /*Crear un nuevo módulo*/
If (!P) /*Si el puntero p es nulo*/
{ printf("\nMemoria insuficiente .); /*Desbordamiento de memoria de salida*/
Return (head); /*Devuelve el puntero del encabezado, lo mismo a continuación*/
}
printf ("Número de entrada (0: final de la lista): ");
scanf("s ", p- gt; num
if (p-> num[0); ] = = ' 0 ')break; /*Si el primer carácter del número de estudiante es 0, la entrada finaliza*/
printf("Ingrese el nombre: ");
scanf("s " , p- gt; nombre);
printf("Ingrese d puntos\n ", 3 /*Solicitud para comenzar a ingresar puntos*/
s = 0; /* Calcula la puntuación total de cada alumno, el valor inicial es 0*/
for(I = 0; I lt3; I ) /*3 cursos ciclados 3 veces*/
{
Hacer {
printf("puntuación d: ", I 1
scanf("d ", ampp->); ; puntuación[I]) ;
If (p->score[I] lt;0 | | p->score[I] gt;100) /*Asegúrate de que la puntuación esté entre 0 y 100 */
printf("Error de datos, vuelva a ingresar.
\ n ");
} while(p- gt; puntuación[I] lt; 0 | | p->; puntuación[I] gt; 100);
s = s p- gt; Score[I]; /* Acumular las puntuaciones de todas las materias*/
}
p->; sum = s /*Guardar la puntuación total* /
p->; Average = (float)s/3; /*Convierta S a tipo flotante mediante conversión de tipo forzada y luego obtenga el valor promedio*/
p- >; Order = 0; /*El valor es 0 antes de ordenar */
p->; Next = head /*Usar el primer nodo como el nodo sucesor del nuevo nodo de entrada*/
head = p; /*El nuevo nodo de entrada es el nuevo nodo principal*/
}
Return (head);
}
/*Función para mostrar todos los registros*/
Desactivar impresión (avatar de estudiante*)
{ int I = 0 /*Número de registros estadísticos* /
Estudiante* p; /*Mover puntero*/
clr SCR();
p = head /*El valor inicial es el puntero de cabeza; */
printf(" \ n * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *Estudiantes* * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("-\ n ");
printf (" | Rec | Num | Nombre | sc 1 | Sc2 | Sc3 | Suma | Ave | Orden | \ n "); /p>
Y (p!=null)
{
i ;
printf(" | 3d | 4s | -4s | 3d | 3d | 3d | 3d | 4.2f | -5d | \n ",
i, p- gt; num, p-> nombre, p- gt; puntuación [0], p- gt; [1], p- gt; puntuación[2], p- gt; suma, p->promedio, p- gt;
p = p- gt;
}
printf("-\ n ");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * FIN * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n ");
}
/*Función de búsqueda de registro*/
Búsqueda no válida (estudiante * responsable)
{Estudiante * p; /*Mover puntero*/
char s[5]; /*Matriz de caracteres utilizada para almacenar nombres*/
clr SCR();
printf("Ingrese un nombre de búsqueda. \n ");
scanf("s ", s);
p = head; /*Asigna el puntero principal a p*/
mientras (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 es nulo*/
p = p- gt /* Mueve el puntero al; siguiente nodo* /
If (p!=NULL) /*Si el puntero no es nulo*/
{ printf(" \ n * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *);
printf("-\ n ");
printf(" | Num | Nombre | sc 1 | sc2 | sc3 | Suma | Ave | Orden | n ");
printf("-\ n ");
printf(" | 4s | 4s | 3d | 3d | 3d | 3d | 4.2f | -5d | \n ",
p->; num, p-> nombre, p- gt; puntuación [0], p- gt; puntuación [1] , p- gt ; puntuación[2], p- gt; suma, p->promedio, p-gt;
printf("-\ n "); >printf( " * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * FIN * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
}
Otro
printf ("\ No hay ningún estudiante con el número s en la lista n.
\n", s);/*No mostrar estudiantes*/
}
/*Función eliminar registro*/
Estudiante* Eliminar (encabezado Estudiante* )
{ int n;
Estudiante *p1, *p2/*p1 es el puntero al nodo que se va a eliminar, p2 es su puntero predecesor*/
char c, s[6];/*s[6] se usa para almacenar el número de estudiante, C se usa para ingresar letras*/
clr SCR();
printf(" Ingrese el número eliminado: ");
scanf("s ",
p 1 = p2 = encabezado /* Asigne el puntero del encabezado del valor inicial; a p1 y p2 */
while(strcmp(p 1->; number, s) and amp ampp1!= NULL) /*Cuando el número de estudiante registrado no es el que estás buscando, o el el puntero no es nulo*/
{ p2 = p 1;/*Asigna el valor del puntero de p1 a p2 como el puntero predecesor de p1*/
p 1 = p 1- >;Siguiente;/ *Apunte el puntero p1 al siguiente registro*/
}
if(strcmp(p 1->;Num, s)==0) /* El número de estudiante encontrado*/
{ printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *Encontrado* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf(" -\ n ");
printf(" | Num | Nombre | sc 1 | sc2 | sc3 | Suma | Ave | Orden | \ n ");
printf("- \ n ");
printf(" | 4s | 4s | 3d | 3d | 3d | 3d | 4.2f | -5d | \ n ",
p 1->; num, p 1-> nombre, p 1-> puntuación [0], p 1-> puntuación [1], p 1-> puntuación [2], p 1-> suma, p 1-> valor promedio, p 1->; orden);
printf("-\ n ");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * FIN * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("¿Está seguro de que desea eliminar al estudiante Y/N? "); /* Preguntar si desea eliminar, ingrese y para eliminar, ingrese n para salir*/
for(;;)
{scanf("c ", ampc);
if(c = = ' N ' | | c = = ' N ')break /*Si no lo eliminas, saldrás de este bucle*/
if(c=='y '||c=='Y ')
{
If(p 1 == cabeza)/* Si p 1 == cabeza, el nodo eliminado es el primer Nodo*/
head = p 1-> next /*dale a head el segundo nodo;
Dirección */
Otro
p2->; next = p 1->; next /* De lo contrario, asigne la siguiente dirección de nodo a la dirección de nodo anterior */< /p >
n = n-1;
printf("\nSe han eliminado un total de s estudiantes.\n", s);
printf("No olvidar Guardar \n "); Romper; /*Eliminar y salir del bucle*/
}
}
}
Otros
printf("\nNo hay ningún estudiante con el número s en la lista.\n", s); /*Nodo encontrado*/
Return (head);
p>
}
/*Función de clasificación*/
Clasificación de estudiante* (Estudiante*cabeza)
{ int I = 0; /*Guardar clasificación*/
Estudiantes *p1, *p2, *t, *temp/*Definir puntero temporal*/
temp = head- gt; /* transferir la tabla original El siguiente nodo señalado por el puntero principal se utiliza como puntero principal*/
head->; next = NULL/*El primer nodo es el nodo principal de la nueva tabla* /
while(temp ! =NULL) /*Ordenar cuando la tabla original no está vacía*/
{
t = temperatura /*Obtener la temperatura; nodo principal de la tabla original*/
temp = temp- gt; next /*Mover el puntero del nodo principal original hacia atrás*/
p 1 =head; Establezca el puntero móvil p1, comenzando desde el puntero principal*/
p2 = head /*Establezca el puntero móvil p2 como el predecesor de p1, y el valor inicial es el puntero principal*/
mientras(t->; promedio ltp 1->; promedio amp ampp1! =NULL) /*Comparar las puntuaciones promedio*/
{
p2 = p 1 /*Cuando el valor del punto de clasificación es menor, el puntero de la nueva tabla se moverá hacia atrás*/
p 1 = p 1->
}
<; p>If(p1==p2) /*p1==p2, indica que debe ordenarse El punto tiene un valor grande y debe clasificarse en primer lugar*/{
t- >; next = p 1; /*El sucesor del punto a ordenar es p*/
head = t /*El nuevo nodo principal es el punto a ordenar*/
}
De lo contrario /*El punto a ordenar se insertará en el medio Entre p2 y p1, si P está vacío, es la cola*/
{
t->; siguiente = p 1; /*t va seguido de p1*/
p2->;siguiente = t;/*p2 seguido de t*/
}
}
p 1 =head;/* El puntero de encabezado ordenado se asigna a p1, listo para completar la clasificación*/
Y (p1! =NULL) /*Cuando p1 no esté vacío, realice las siguientes operaciones*/
{
i; /*Número de serie del nodo*/
p 1 ->; orden = I; /*Asignar número de secuencia de nodo al nivel*/
p 1 = p 1->;Siguiente; /*Mover el puntero hacia atrás*/
}
printf("Ordenar correctamente.
\ n ");/*Clasificación exitosa*/
Regresar (encabezado);
}
/*Insertar función de registro*/
Estudiante*Insertar (Estudiante*Cabeza, Estudiante*Nuevo)
{Estudiante*p0, *p1, *p2
int n, suma1, I; p>p 1 =head; /*Hacer que p1 apunte al primer nodo*/
p0 =Nuevo; /*p0 apunte al nodo a insertar*/
Por favor, ingrese un nuevo registro. \ n "); /* Solicitud para ingresar la información del registro */
printf("Ingrese el número: ");
scanf("s ", new - gt ; num) ;
printf("Ingrese el nombre: ");
scanf("s ", nuevo - gt; nombre); Por favor ingrese d puntos.\n ",3);
suma 1 = 0; /*Guarde la puntuación total del nuevo registro, el valor inicial es 0*/
para (I = 0; I lt3; i )
{
Hacer {
printf("Puntuación d: ", I 1
);scanf(" d ", amp nuevo - gt; puntuación[I]);
if (nuevo - gt; puntuación[I] gt; 100 | | nuevo -> puntuación[I] lt ; 0)
printf("Error de datos, vuelva a ingresar. \n "
} while(new - gt; score[I] gt; 100 | | new ->; puntuación[I ] lt; 0);
suma 1 = suma 1 new- gt; puntuación [I]; }
Nuevo - gt; suma = suma 1;*Almacenar puntuación total en un nuevo registro*/
Nueva - gt; Promedio = suma (flotante) 1/3;
Nuevo - gt; orden = 0;
If(head==NULL) /*La lista enlazada original es una lista vacía*/
{ head = p0P0 ->; next = NULL} /*Utiliza el nodo señalado por p0 como nodo principal*/
Otros
{ while((P0- gt; ltp promedio 1-> ; promedio) amp amp(p 1-> ;¡Siguiente! =NULL))
{ p2 = p 1 /* Haga que p2 apunte al nodo al que p1 acaba de apuntar*/
}
If (P0- gt; promedio gt= p 1->; promedio )
{ if(head == p 1)head = P0; /*Insertar antes del primer nodo original*/
De lo contrario, p2- gt; el nodo al que apunta p2* /
P0->; next = p 1;}
Otro
{ p 1->; >; next = NULL}/ *Insertar después del último nodo*/
}
n = n 1 /*Agregar 1 al número de nodos*/
head=sort(head ); /*Llame a la función de clasificación para reordenar las puntuaciones de los estudiantes*/
printf("\nSe ha insertado el estudiante. \n ", Nuevo - gt; nombre);
printf("No olvides guardar el nuevo archivo.
\n ");
Regresar (head);
}
/*Función para guardar datos en un archivo*/
Guardar no válido (estudiante * cabeza)
{ ARCHIVO * fp/*Definir puntero a archivo*/
Estudiante * p /*Definir puntero móvil*/
char; outfile[10];
printf("Nombre del archivo de entrada y salida, como c:\\score\n");
scanf("s",outfile);
If ((FP = fopen (outfile, " WB))== = null)/*Abra el archivo binario en modo de solo escritura para salida*/
{
printf("No se puede abrir el archivo\n ");
Regresar /*Si no se puede abrir, regresa al menú*/
}
printf(" \nGuardar archivo...\n ");
p = head /*Aleja el puntero del puntero principal*/
Y (p !=NULL ) /*Si p no está vacío*/
{
fwrite(p, LEN, 1, FP) /*Escribir registro*/
<); p>p = p- gt; Siguiente; /*Mover el puntero hacia atrás*/}
fclose(FP);/*Cerrar el archivo*/
printf ("¡Guardar archivo correctamente!\n ");
}
/*Leer datos de la función de archivo*/
Estudiante *Cargar()
{STUDENT *p1, *p2, * head = NULL/*Definir la variable de puntero de registro*/
FILE *fp/*Definir el puntero al archivo*/
char infile[10];
printf("Ingrese el nombre del archivo, como c:\\score\n");
scanf("s" , infile);
If ((FP = fopen (infile, " Rb))== = null)/*Abrir un archivo binario en modo de solo lectura*/
{
printf("No se puede abrir el archivo.
\n ");
Return (head);
}
printf(" \n¡Cargando archivo!\n ");
p1=(Estudiante*)malloc(LEN);/*Crear nuevo módulo*/
If (!p1)
{
printf( "Fuera de memoria!\ n ");
Return (head);
}
head = p 1; /*Aplicar a espacios como puntero de cabecera* /
Y (!Feof(fp)) /*Leer datos en un bucle hasta el final del archivo*/
{
if(fread(p1 , LEN , 1, fp)! = 1)break; /*Si los datos no han sido leídos, salta del bucle*/
p 1->; LEN); /* es Hacer espacio para el siguiente nodo*/
if (!p 1->; siguiente)
{
printf("Fuera) de memoria!\n" );
Return (head);
}
p2 = p 1; /*Hacer que p2 apunte al nodo que acaba de apuntar por p1*/
p 1 = p 1->; Siguiente; /*El puntero se mueve hacia atrás y el enlace de datos se vuelve a leer en el pie de página actual*/
}
p2-> ;next = NULL/*El puntero sucesor del último nodo es null*/
fclose(FP);
printf("Tienes ¡Leí correctamente los datos del archivo!\n ");
Return (head);
}