c sistema de gestión del desempeño de los estudiantes de idiomas
/*Archivo de encabezado*/
# include ltstdio.h gt
# include ltdos.h gt
# include ltstdlib.h gt/*Otros comentarios*/
# include ltstring.h gt/*Funciones de cadena*/
# include ltmem.h gt/* Memoria función de operación*/
# include ltctype.h gt/*Función de operación de caracteres*/
# include ltalloc.h gt/*Función de asignación dinámica de direcciones*/
#Define LEN sizeof (estudiante)
Typedef struct stu /*Define la matriz de estructura utilizada para almacenar en caché los datos*/
{ char num[6];
Nombre del personaje[5];
puntuación int[3];
suma int
Promedio flotante;
secuencia int;
struct stu * next
}Estudiante;
/*Prototipo de función*/
Estudiante* init();/ *Inicialización function*/
int menu _ select() /*Función de menú*/
Estudiante* create() /*Crear una lista vinculada*/
Impresión nula (estudiante * avatar); /*Mostrar todos los registros*/
búsqueda nula (estudiante * jefe); /*Buscar registro*/
Estudiante * eliminar (estudiante *) head); /*eliminar registro*/
estudiante*sort(estudiante*head);/*sort*/
estudiante*insert(estudiante*head, estudiante*nuevo); /*Insertar registro*/
Guardar vacío (estudiante* cabeza); /*Guardar archivo*/
Estudiante* cargar() /*Leer archivo*/
/*Interfaz de función principal*/
Main()
{Estudiante* head, new;
head = init();/ *El la lista enlazada se inicializa de modo que el valor de head sea NULL*/
for(;;)/*Bucle infinito*/
{Switch (menu_select())
{
caso 1: head = create(); break;
Caso 2: print (head)
Caso 3: buscar; (cabeza);
Caso 4: cabeza=eliminar (cabeza);
Caso 5: cabeza=sort (cabeza); >Caso 6: head = insert(head amp; new); /* amp; new significa dirección de correo electrónico de retorno*/
Caso 7: save(head; break);
Caso 8: head = load(); roto;
Caso 9: Salir (0); /*Si el valor de retorno del menú es 9, el programa finaliza*/
}
}
}
/*Función de inicialización*/
Estudiante *init()
{
Devolver NULL/*Devolver puntero nulo*/
}
/*Función de selección de menú*/
menu_select()
{ int n;
Fecha de estructura d; /*Definir estructura de tiempo*/
getda
te(amp;d);/*Lee la fecha del sistema y colócala en la estructura D */
printf("Presiona cualquier tecla para ingresar al menú...");/*Presiona cualquier tecla para ingresa al menú principal */
getch() /*Lee los caracteres del teclado, pero no los muestra en la pantalla*/
clr SCR(); la pantalla*/
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("\t\tBienvenido\ n ");
p>printf("\n\t\tSistema de gestión del rendimiento estudiantil";
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *menú* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf("\t\t\t1. Ingrese el registro\ n "); /*Ingrese el registro del estudiante*/
printf ("\t\t\ t2. Imprimir registros\n "); /*Mostrar*/
printf("\t\t\t3. Buscar registros por nombre\n "); */
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 registros en la lista\n "); /*Insert*/
printf("\t \t\t7. Guardar 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*/
Hacer {
printf("\n\t\t\tIngrese su elección (1~9):");
scanf("d", ampn);
} while(n lt ; 1 | | n > 9); /*Si el elemento seleccionado no está entre 1 y 9, ingrese nuevamente*/
Regresar (n); llama a la función correspondiente según el número*/
}
/*Función de entrada*/
Estudiante*Crear()
{int i, s;
Estudiante *head=NULL, * p; /*Definir función devuelve un puntero al encabezado de la lista enlazada*/
clr () ;
for(;;)
{ p =(STUDENT *)malloc(LEN);/*Crear un nuevo módulo*/
Si (!P ) /*Si el puntero p es nulo*/
{ printf("\nMemoria insuficiente.); /*Desbordamiento de memoria de salida*/
Retorno (head); / *Regresar puntero principal, 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, el extremos de entrada*/
printf("Ingrese el nombre: ");
scanf("s ", p- gt; nombre
printf(" Por favor ingrese d puntos \n ", 3); /*Solicitud para comenzar a ingresar puntajes*/
s = 0; /*Calcule el puntaje total de cada estudiante, el valor inicial es 0*/
for (I = 0; Ilt3; I) /*3 cursos ciclos 3 veces*/
{
Hacer {
printf( "Puntuación d: ",I 1);
scanf("d", ampp->puntuación[I]);
if (p->puntuación[I] lt; 0 | p->score[I] gt;100) /*Asegúrese 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 y dirección.
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 | Promedio | 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 , 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 ningún estudiante*/
}
/*Función eliminar registro*/
Eliminar estudiante* (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, p1->promedio valor, 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; puntaje[I] gt; 100 | | nuevo); ->; 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 el 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);
}