Ya ajustado, aproximadamente equivalente en función
#include lt; stdio.hgt
#include lt;
#include lt; string.hgt; /*Función de cadena*/
#include lt;
typedef struct stu /*Definir matriz de estructura para almacenar datos en caché*/
{
char num[6]
char name; [5];
puntuación int[3];
suma int
promedio flotante
orden int; >
struct stu *next;
}ESTUDIANTE
/*Función de inicialización*/
ESTUDIANTE *Init()
{
return NULL; /*devuelve puntero nulo*/
}
/*función de selección de menú*/
int Menu_Select ()
{
int n;
struct tm *pt; /*Definir estructura de tiempo*/
time_t t;
t=time(NULL);
pt=localtime(amp;t); /*Leer la fecha del sistema y ponerla en la estructura*/
printf("\nPresione cualquier tecla para ingresar al menú principal... \n"); /*Presione cualquier tecla para ingresar al menú principal*/
//getch() / *Leer un carácter desde el teclado, pero no mostrarlo en la pantalla*/
system("pause");
system("cls"); /p>
printf("****************************************** * **************************************\n");
printf("\t\t Bienvenido a\n");
printf("\n\t\t\t Usando Student Management System 1.0\n"); > printf("************************************MENÚ********* * *******************************\n");
printf("\t\ t \t1. Ingrese el registro de calificaciones del estudiante Ingrese el registro\n"); /*Ingrese el registro de calificaciones del estudiante*/
printf("\t\t\t2. Display Imprima el registro\n" ); / *Mostrar*/
printf("\t\t\t3. Buscar registro en nombre\n"); /*Buscar*/
printf("\t \t \t4. Eliminar Eliminar un registro\n"); /*Eliminar*/ <
/p>
printf("\t\t\t5. Ordenar Ordenar para crear un archivo Nuevo\n"); /*Ordenar*/
printf("\t\t\t6. Insertar registro en la lista\n"); /*Insertar*/
printf("\t\t\t7. Guardar el archivo\n"); /*Guardar*/
printf("\t\t\t8. Leer Cargar el archivo\n"); /*Leer*/
printf("\t\t\t9. Salir\n "); Salir*/
printf("\n****************************** ***** ********************************************\n") ;
printf("\t\t\t\tFecha actual del sistema: d-d-d\n", pt-gt; tm_year 1900, pt-gt; tm_mon 1, pt-gt; tm_mday); Mostrar la fecha actual del sistema*/
do
{
printf("\n\t\t\tIngrese su elección su elección(1~9) : ");
fflush(stdin);
scanf("d", amp; n);
} while (nlt; 1||ngt ; 9); /*Si la selección no está entre 1 y 9, vuelva a ingresar*/
return(n); /*Devuelve la selección y la función principal llamará a la función correspondiente*/
}
/*Función de entrada*/
ESTUDIANTE *Crear()
{
int i , s;
ESTUDIANTE *head=NULL, *p; /* Definir función. );
for(;;)
{
p=(ESTUDIANTE *)malloc(LEN /*Abrir una nueva Unidad*/
if(!p) /*Si el puntero p está vacío*/
{
printf("\nMemoria de salida desbordada. Sin memoria."); *Desbordamiento de memoria de salida*/
return (head); /*Devuelve el puntero del encabezado, lo mismo a continuación*/
}
printf ("Ingrese el número de estudiante Ingrese num(0: fin de lista):");
scanf("s", p-gt; num);
if(p-gt ;num[ 0]=='0') break; /*Si el primer carácter del número de estudiante es 0, finalice la entrada*/
printf("Ingrese el nombre: "
<); p> scanf("s", p-gt; name);printf("Ingrese las puntuaciones d\n", 3 /*Solicitud para comenzar a ingresar puntuaciones* /
);s=0; /*Calcula la puntuación total de cada alumno, el valor inicial es 0*/
for(i=0;ilt;3;i) /*Recorrer 3 cursos 3 veces*/
{
do
{
printf("puntuación:", i 1
scanf("d", amp; p-gt; puntuación[i]); ;score[i]lt;0 || p-gt;score[i]gt;100) /*Asegúrese de que la puntuación esté entre 0 y 100*/
printf("Error de datos, vuelva a -ingrese Error de datos, por favor ingrese nuevamente.\n");
} while(p-gt; puntaje[i]lt; 0 || p-gt; puntaje[i]gt; 100);
s=s p-gt; score[i]; /*Suma las puntuaciones de cada materia*/
}
p-gt; s; /*Guardar la puntuación total*/
p-gt; Average=(float)s/3; /*Utilice la conversión de tipo forzada para convertir s en tipo flotante y luego encuentre el promedio* /
p-gt; order=0; /*Este valor es 0 antes de ordenar*/
p-gt; next=head /*Utiliza el nodo principal como nuevo; nodo de entrada El nodo sucesor del punto*/
head=p; /*El nuevo nodo de entrada es el nuevo nodo principal*/
}
return( head );
}
/* Mostrar todas las funciones de registro*/
void Print(ESTUDIANTE *head)
{
int i=0; /* Número de registros estadísticos*/
ESTUDIANTE *p; /*Mover puntero*/
system("cls"); /p>
ESTUDIANTE *p; p>
p=head; /*El valor inicial es el puntero de la cabeza*/
printf("\n******* ************ ******************ALUMNO******************* ***************** ***\n");
printf("--------------- ----------------- --------------------------------- -----------------\n" );
printf("| Rec | Num | Nombre | Sc1 | Sc2 | Sc3 | Suma | Ave | Orden |\n");
printf("---- ------------------------------ -------------------- -----------------------\n");
while(p!=NULL)
{
i
printf("| 3d | 4s | -4s | 3d | 3d | 3d | 3d | 4.2f | -5d|\n",
i, p-gt; num, p-gt; nombre, p-gt; puntuación[0], p-gt; puntuación [1], p-gt; puntuación [2], p-gt;
m, p-gt; promedio, p-gt; orden);
p=p-gt;
}
printf("-- -------------------------------------------------- --------------------------\n");
printf("******* * *****************************FIN******************** **** *******************\n");
}
/*Función de búsqueda de registro*/
void Search(ESTUDIANTE *cabeza)
{
ESTUDIANTE *p /* Mover puntero*/
char s[5 ]; /* Matriz de caracteres para almacenar nombres*/
system("cls");
printf("Ingrese un nombre para buscar.\n"); >
scanf("s", s);
p=head; /*Asigna el puntero principal a p*/
while(strcmp(p- gt; nombre). , s) amp; amp; p != NULL) /*Cuando el nombre grabado no es el que buscas, o el puntero no es nulo*/
p=p-gt; *Mover el puntero al siguiente nodo*/
if(p!=NULL) /*Si el puntero no es nulo*/
{
printf ("\n************************************ENCONTRADO******* ** ****************************\n");
printf("------- -------------------------------------------------- -----------------------\n");
printf("| Num | Nombre | sc1 | sc2 | sc3 | Suma | Ave | Orden |\n");
printf("------------------------------ ---- ----------------------------------------\n ");
printf("| 4s | 4s | 3d | 3d | 3d | 3d | 4.2f | -5d|\n",
p-gt; num, p -gt;nombre ,p-gt;puntuación[0],p-gt;puntuación[1],p-gt;puntuación[2],p-gt;suma,p-gt;promedio,p-gt;orden)
printf("------------------------------------------ ---- ------------------------------------\n");
printf( "******************************************
*FIN******************************************\n");
}
else
printf("\nNo hay ningún estudiante en la lista.\n", s); estudiante* /
}
/*Función eliminar registro*/
ESTUDIANTE *Eliminar(ESTUDIANTE *cabeza)
{
//int n;
ESTUDIANTE *p1, *p2; /*p1 es el puntero del nodo que se eliminará y 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*/
system("cls"); > printf(" Ingrese el número eliminado: ");
scanf("s",
p1=p2=head /*Proporcione las asignaciones iniciales de p1 y p2; puntero de cabeza de valor*/
while(strcmp(p1-gt; num, s) amp; amp; p1 != NULL) /*Cuando el número de estudiante registrado no es lo que está buscando, o un puntero Cuando no está vacío*/
{
p2=p1 /*Asigna el valor del puntero p1 a p2 como puntero predecesor de p1*/
p1; = p1-gt; next; /*Apunta el puntero p1 al siguiente registro*/
}
if(strcmp(p1-gt; num, s)==0) /* ID de estudiante encontrado*/
{
printf("*************************** ***** ************ENCONTRÓ******************************** ****\ n");
printf("------------------------------- ----------------- --------------------------------- ---------------\n");
printf("| Num | Nombre | sc1 | sc2 | sc3 | Suma | Ave | Orden |\n"
printf("---------- ---------------------- ---------------------- ------------------\n");
printf("| 4s | 4s | 3d | 3d | 3d | 3d | 4.2f | -5d|\n",
p1-gt; num, p1-gt; nombre, p1-gt ; puntuación[0], p1-gt; puntuación[1], p1-gt; puntuación[ 2], p1-gt; suma, p1-gt; printf("------------------ ----------------------- --------------------- -----------\n");
printf("*** **
**********************************FIN*************** * *************************\n");
printf("\nSi desea eliminar, ingrese Y para eliminar, N si sale\n¿Está seguro de eliminar al estudiante Y/N?"); /*Pregunte si desea eliminar, ingrese Y para eliminar, N para salir*/
for(;;)
{
scanf("c", y c
if(c=='n'||c=='N') break; /*si no es Eliminar, entonces salta de este bucle*/
if(c=='y'||c=='Y')
{
if(p1 ==head) /*Si p1==head, significa que el nodo eliminado es el primer nodo*/
head=p1-gt; la dirección del segundo nodo al encabezado* /
else
p2-gt; next=p1-gt; next /* De lo contrario, asigne la siguiente dirección de nodo a la dirección de nodo anterior*; /
//n=n-1;
printf("\nEl número de estudiante es (Num): s estudiante ha sido eliminado.\n",
printf("No olvides Guardar.\n"); break /*Saltar del bucle después de la eliminación*/
}
}
}
else
printf("\nNo hay ningún número de estudiantes en la lista.\n" , s); /*No se puede encontrar el nodo* /
return(cabeza);
}
/*Función de clasificación*/
ESTUDIANTE *Ordenar(ESTUDIANTE *cabeza)
{
int i=0; /*Guardar clasificación*/
ESTUDIANTE *p1,* p2, *t, *temp; */
temp=head-gt; next; /*Utilice el siguiente nodo señalado por el puntero principal de la tabla original como puntero principal*/
head-gt; =NULL /*El primer nodo es el nodo principal de la nueva tabla*/
while(temp!=NULL) /*Cuando la tabla original no está vacía, ordena*/
{
t=temp; /*Obtener el nodo principal de la tabla original*/
temp=temp- gt siguiente /*Mover el puntero del nodo principal original hacia atrás; */
p1=head; /*Establece el puntero móvil p1, comenzando desde el puntero principal*/
p2=head ; p1, y el valor inicial es el puntero de la cabeza*/
while (t-gt; Averagelt; p1-gt; Averageamp; amp; p1!=NULL) / *Comparar las puntuaciones promedio*/
{
p2=p1; /*Si el valor de puntos a ordenar es pequeño, el nuevo puntero de la tabla se moverá hacia atrás*/
p
1=p1-gt; next;
}
if(p1==p2) /*p1==p2, lo que indica que el punto a ordenar tiene un valor grande y debe ocupar el primer lugar*/
{
t-gt; next=p1 /*El sucesor del punto a ordenar es p*/
head; =t; /*Nuevo nudo de cabeza El punto es el punto a ordenar*/
}
else /*El punto a ordenar debe insertarse en algún lugar en el medio entre p2 y p1, si p está vacío, es la cola*/
{
t-gt; next=p1 /*El sucesor de t es p1*/
p2-gt; next=t; /*p2 El sucesor de es t*/
}
}
p1=head; *El puntero de encabezado ordenado se asigna a p1, listo para completar la clasificación* /
while(p1!=NULL) /*Cuando p1 no esté vacío, realice las siguientes operaciones*/
{
i; /*Número de serie del nodo*/
p1-gt; orden=i /*Asignar el número de serie del nodo al ranking*/
p1=p1-gt; next; /*Mover el puntero hacia atrás* /
}
printf("La clasificación se realizó correctamente.\n"); es exitoso*/
return (head);
p>}
/*Insertar función de registro*/
ESTUDIANTE *Insertar (ESTUDIANTE *cabeza, ESTUDIANTE *Nuevo)
{
ESTUDIANTE *p0, *p1, *p2
//int
;int sum1, i;
p1=head; / *Hacer que p1 apunte al primer nodo*/
p0=New /*p0 apunta al nodo a ser insertado*/
printf("\nIngrese un nuevo registro. \n"); /*Solicitud para ingresar la información del registro*/
printf("Ingrese el número de estudiante: " );
scanf("s", New-gt; num);
printf("Ingrese el nombre:
scanf("s); ", New-gt; nombre);
printf ("Ingrese las puntuaciones d.\n", 3);
sum1=0; /*Guarde la puntuación total de el nuevo registro, el valor inicial es 0*/
for( i=0; ilt; 3; i )
{
do
{
printf("puntuación:",i 1
scanf("d", amp; New-gt; puntuación[i]); >
if(New-gt; puntuación[i]gt; 100|| New-gt; puntuación[i]lt; 0)
printf("Error de datos, por favor ingrese nuevamente.\n ");
} while(Nuevo-gt; puntuación[i]gt;100||Nuevo-gt;puntuación[
i]lt; 0);
sum1=sum1 New-gt; puntuación[i] /*Acumular puntuaciones para cada materia*/
}
New -gt; sum=sum1; /*Guardar la puntuación total en el nuevo registro*/
New-gt; ; orden=0;
if(head==NULL) /*La lista enlazada original es una lista vacía*/
{
head=p0;
p0-gt; next=NULL;
} /*Convertir el nodo al que apunta p0 como nodo principal*/
else
{
while((p0-gt; promedio; p1-gt; promedio)amp; amp; (p1-gt; next!=NULL))
{
p2=p1; /*Hacer que p2 apunte al nodo señalado por p1*/
p1=p1-gt; /*Mover p1 un nodo hacia atrás*/
}
if(p0-gt;averagegt;=p1-gt;average)
{
if(head==p1)head =p0; /*Insertar antes del primer nodo original*/
else p2-gt; next=p0 /*Insertar después del nodo señalado por p2*/
p0- gt; ; siguiente=p1;
}
más
{
p1-gt; siguiente=p0; > p0-gt; next=NULL;
} /*Insertar después del último nodo*/
}
//n=n 1 ; Agregue 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("\nEstudiante Estudiante s se han insertado.\n", New-gt; nombre);
printf("No olvide guardar el nuevo archivo.\n");
return(head
}
/*Función Guardar datos en archivo*/
void Save(ESTUDIANTE *head)
{
ARCHIVO *fp; /*Definir el puntero al archivo*/
ESTUDIANTE *p; /*Definir el puntero en movimiento*/
char outfile[10]
printf("Archivo de salida, por ejemplo: c:\\score Ingrese el nombre del archivo de salida, por ejemplo c:\\score\n"); outfile);
if((fp=fopen(outfile, "w"))==NULL) /*Abrir un archivo binario para salida, modo de solo escritura*/
{
printf("No se puede abrir el archivo\n");
return;
/*Si no se puede abrir, regresa al menú*/
}
printf("\nGuardando el archivo...\n"); > p=head; /*Mover el puntero comenzando desde el puntero principal*/
while(p!=NULL) /*Si p no es nulo*/
{
fwrite(p, LEN, 1, fp); /*Escribir un registro*/
p=p-gt /*Mover el puntero hacia atrás*/
}
fclose(fp); /*Cerrar el archivo*/
printf("Guarde el archivo correctamente....¡Guarde el archivo correctamente!\n") ;
}
/* Función para leer datos del archivo*/
ESTUDIANTE *Load()
{
ESTUDIANTE *p1, *p2, *head=NULL; /*Definir variable de puntero de registro*/
ARCHIVO *fp /*Definir puntero a archivo*/
char infile[10];
printf("Vierta en el archivo, por ejemplo: c:\\score Ingrese el nombre del archivo, por ejemplo c:\\score\n"); ( "s", infile);
if((fp=fopen(infile, "r"))==NULL) /*Abrir un archivo binario en modo de solo lectura*/
{
printf("No se puede abrir el archivo.\n");
return(head
}
p); >printf("\nCargando el archivo!\n");
p1=(ESTUDIANTE *)malloc(LEN); /*Abrir una nueva unidad*/
if(!p1)
{
printf("¡Desbordamiento de memoria! ¡Sin memoria!\n"); >
}
head=p1; /*Solicitar espacio y usarlo como puntero principal*/
while(!feof(fp) ) /*Leer datos en un bucle hasta el final del archivo*/
{
if(fread(p1, LEN, 1, fp)!=1) break /*Si no se leen los datos; , salta del bucle*/
p1-gt; next=(STUDENT *)malloc(LEN); /*Crea espacio para el siguiente nodo*/
if(! p1-gt; siguiente)
{
printf("¡Sin memoria!\n");
return (head); p> }
p2=p1; /*Hacer que p2 apunte al nodo señalado por p1*/
p1=p1-gt; nueva lectura Ingrese el enlace de datos al final de la tabla actual*/
}
p2-gt; next=NULL /*El puntero sucesor del último nodo es nulo*; /
fclos
e(fp);
printf("\n¡Has leído correctamente los datos del archivo!\n");
return (head);
/*Interfaz de función principal*/
int main()
{
ESTUDIANTE *head, Nuevo
;head=Init(); //Inicializa la lista enlazada para que el valor de head sea NULL
for(;;) //Tiempos de bucle infinitos
{
switch(Menu_Select())
{
caso 1: head=Create();
p>
caso; 2: Imprimir (cabeza);
caso 3: Buscar (cabeza);
caso 4: eliminar (cabeza); p> caso 5: head=Sort(head);
caso 6: head=Insert(head, amp; New); //amp; p> caso 7: Guardar(cabeza);
caso 8: cabeza=Cargar();
caso 9: salir(0) ; el valor de retorno es 9, el programa finaliza
}
}
devuelve 0;