Diseño de proyecto "Programación en lenguaje C"

estudiante *cancel(student *head, long int num); cancel() se usa para eliminar información del candidato.

estudiante *find(student *head, long int num); //La función de puntero *find() se usa para encontrar información del candidato. p> void inorder(student * head); //Defina la función inorder() para organizar las puntuaciones totales de los candidatos de mayor a menor y generarlas

void Average(student *head);//Función para encontrar la puntuación promedio de los estudiantes

void save(student *head); //Guardar función

estudiante *Read() //Leer función

; privado:

estudiante *p1, *p2, *p3, *cabeza, st

}

Información:: Información()

{

coutlt;lt;" ********************************** ********* *************************************\n";

coutlt;lt; "-----------------------lt;lt;Bienvenido a utilizar el sistema de gestión del desempeño estudiantilgt;gt ;---------- ---------------\n";

coutlt;lt;" ******** ************ **************************************** ************* ********\n\n";

}

Información::~Información()

{

coutlt;lt;" ******************************* ************ *************************************\ n";

coutlt;lt;" --------------------------lt;lt;Gracias por utilizar el sistema de gestión del desempeño estudiantilgt;gt;---------- -------------\n";

coutlt;lt;" **** ******************* ********************************** ****************** *******\n";

}

estudiante *Información::creat (void)

{//Defina un puntero para estructurar al estudiante. La función de puntero de estructura *creat() se utiliza para agregar información del candidato

char ch[Q];

; //Se utiliza para almacenar nombres

p1=p2=(student *)malloc(LEN); //Llama a la función malloc() para abrir una nueva unidad de almacenamiento

coutlt; lt;"-------------lt;lt;Cree una tabla de información del examen del estudiante y finalice la entrada con ! en el nombre.

gt；gt;--------------"lt;lt;endl;

coutlt;lt;" Nombre: ";

cingt; gt; ch;

head=NULL; //Asigna un valor inicial al puntero

while (strcmp(ch, "!")!=0)

{// Llame a la función de comparación de caracteres strcmp() para determinar si continuar input

char str[10]

int flag=0

strcpy(p1-gt;name, ch); estructura de bucle al frente Copie el nombre en el nombre de la matriz de la estructura denominada p1

coutlt;lt;"Gender:"

cingt;gt;p1-gt;sex; /p>

coutlt; lt; "Número de boleto de admisión (8 dígitos): ";

do{

cingt; if(atol (str)gt;99999999 || atol(str)lt;1)

coutlt;lt;"¡¡¡Lo siento, ingrésalo correctamente!!!\n"; > else

else

coutlt;lt;"¡¡¡Lo siento, ingrésalo correctamente!!!\n"; p>

{

p1- gt; id=atol(cadena); bandera=1;

}

}mientras(bandera==0 );

bandera=0; p>

coutlt;lt; "Puntuación del principio de composición por computadora:";

do{

cingt;

if(atoi( str)gt;100 || atoi(str)lt;1)

coutlt;lt;"¡Lo siento, ingresa un número entre 1 y 100!\n";

{

p1-gt; puntuación[0]=atoi(str);

}

}mientras (flag==0);

flag=0;

coutlt;lt;" Resultados de estadísticas de probabilidad: "

do{

cingt; gt; str;

if(atoi(str)gt; 100 || atoi(str)lt; 1 )

coutlt;lt;"Lo siento, ingresa ¡¡un número entre 1 y 100!!\n";

else

{ p1-gt; score[1]=atoi(str); flag=1;}

} while(flag==0);

flag=0;

coutlt ;lt;"Puntuación en inglés:"

do{

cingt;gt;str;

if(atoi(str)gt;100 || atoi (str)lt;1)

coutlt;lt; "¡¡Lo siento, ingresa un número entre 1 y 100!!\n";

else

{ p1-gt; puntuación[2]=atoi(str); ;}

} while(flag==0);

flag=0;

coutlt;lt; "C grado:"

hacer{

cingt;gt;str;

if(atoi(str)gt;100 || atoi(str)lt;1)

coutlt;lt;"Lo siento, por favor ¡¡Ingresa un número entre 1-100!!\n";

else

{ p1-gt; score[3]=atoi(str); flag=1;} < / p>

} while(bandera==0);

bandera=0;

p1-gt; total=p1-gt; score[1] p1-gt;score[2] p1-gt;score[3];//Calcular el puntaje total

if(n==0)head=p1;//Si es así input Para el primer grupo de información del examen del estudiante, asigne el puntero p1 al cabezal del puntero

else p2-gt next=p1 // De lo contrario, asigne p1 al siguiente puntero de la estructura señalada por p2

p2=p1; //Asigna el puntero p1 al puntero p2

n; //Aumenta el valor de n en 1

coutlt;lt;"Nombre: ";

p>

cingt; gt; ch; // Almacena el nombre ingresado en la matriz de caracteres ch

}

p2-gt; next=NULL; // Almacena p2 Al siguiente puntero de la estructura puntiaguda se le asigna un valor nulo

return (head); //Devuelve el primer conjunto de información del examen del estudiante ingresado

}

//---------------gt; Defina la función de salida () para generar la información del candidato a partir del contenido señalado por el puntero principal

void Information::output(student * head)

{

if(head==NULL) coutlt;lt;" Esta es una tabla vacía, ingrese la puntuación del candidato primero.\n";

else{

coutlt;lt;"-------------------- -------------- ------------------------------------ ------------\n";

coutlt;lt;" *Tabla de información de puntuación de exámenes del estudiante*\n";

coutlt;lt; "---------------- --------------------------------- ----------------- -------------\n";

coutlt;lt;"Número de entrada Nombre Género Computadora Composición Principio Probabilidad Estadísticas Inglés C Puntuación promedio Puntuación total\n";

coutlt;lt;"---------------------- -------------------- ------------------------------ ----------\n";

p1=head; //Asigna el puntero principal a p

do

{

coutlt;lt;setw(8)lt;lt;p1- gt;id

lt;lt;setw(9)lt;lt;p

1-gt;nombre

lt;lt;setw(8)lt;lt;p1-gt;sexo

lt;lt;setw(13)lt;lt;p1- gt;puntuación[0]

lt;lt;setw(16)lt;lt;p1-gt;puntuación[1]

lt;lt;setw(10)lt; lt;p1-gt;puntuación[2]

lt;lt;sew(9)lt;lt;p1-gt;puntuación[3]

lt;lt;sew( 6)lt;lt;p1-gt;total/4.0

lt;lt;setw(11)lt;lt;p1-gt;totallt;lt;endl

coutlt; ;es;"---------------------------------------------- -----------------------------------\n";

p1=p1 -gt; next; //Asigna el siguiente puntero del siguiente conjunto de información candidata a p

} while(p1!=NULL); // Si el puntero p no está vacío, continúa. es transferir toda la información del candidato. Páselo al puntero p y luego envíelo

}

}

//----------. --gt; Cuenta el número de estudiantes Función

int Información::count(struct Student *head)//Define la función count() para contar el número total de candidatos

{

if(head==NULL )

return(0); //Si el encabezado del puntero está vacío, el valor de retorno es 0

else return( 1 count(head-gt; next)); //Recursión de la función Llamada

}

//----------gt; calificaciones de los estudiantes

estudiante *Información:: insertar (estudiante *cabeza)

//Insertar un nuevo nodo y definir una función de puntero de estructura *insertar() que apunta a la estructura del estudiante para agregar información del candidato

{

char str[10];

int flag=0; --------------- -lt;lt;Ingrese la información de puntuación del nuevo estudiantegt;gt;----------------\n"lt ;lt;endl;

p1= (student *)malloc(LEN); //Hacer que p1 apunte al nuevo nodo insertado

coutlt;lt;"Name:"; /p>

cingt;gt;p1-gt; name; //Guarde el nombre ingresado en el nombre de la matriz de la estructura llamada p1

coutlt;lt; >

cingt;gt;p1-gt; sexo;

coutlt; "Número de boleto de admisión (8 dígitos): "; p> cingt; gt; str;

if(atol(str)gt;99999999 || atol(str)lt;1)

coutlt;lt;"Lo siento, ingresa correctamente!!!\n";

else

{p1-gt; id=atol(str); bandera=1; }

}mientras(bandera==0); > flag=0;

coutlt; lt; "Puntuación del principio de composición de la computadora:";

do{

cingt;

if(atoi(str)gt;100 || atoi(str)lt;1)

coutlt;lt;"¡¡Lo sentimos, por favor ingresa un número entre 1 y 100!!\n" ;

else

{ p1-gt; puntuación[0]=atoi(str); bandera=1 }

}mientras(bandera==0 ) ;

flag=0;

coutlt; "Resultados de estadísticas de probabilidad:"

do{

gt; str;

if(atoi(str)gt;100 || atoi(str)lt;1)

coutlt;lt;"¡Lo siento, ingresa un número entre 1 y 100! !\n";

else

{ p1-gt; puntuación[1]=atoi(str); bandera=1;}

}mientras( flag==0);

flag=0;

coutlt;lt; "Puntuación en inglés:"

do{

cingt;gt;str;

if(atoi(str)gt;100 || atoi(str)lt;1)

coutlt;lt;"Lo siento, ingresa un número ¡¡entre 1-100!!\n";

else

{ p1-gt; puntuación[2]=atoi(str); flag=1;}

} while(flag==0);

flag=0;

coutlt;lt; "Calificación C:"

hacer{

cingt; gt;

if(atoi(str)gt; 100 || atoi(str)lt; 1)

coutlt; , ¡ingrese un número entre 1 y 100!\n";

else

{ p1-gt; score[3]=atoi(str); flag=1;}

} while(flag==0);

flag=0;

p1-gt; gt; puntuación[1] p1-gt; puntuación[2] p1-gt; puntuación[3]; //Calcular la puntuación total

p2=head; p>

if(head==NULL) // Si no se llama a la función anterior, el puntero del encabezado está vacío

{

head=p1 -gt; ; next=NULL;

}//Asigne p1 al puntero principal y asigne un valor nulo a next, el puntero del miembro de la estructura al que apunta p1

else

{

mientras((p1-gt;idgt;p2-gt;id)amp;a

mp; (p2-gt; next!=NULL))

{

p3=p2; //p3 apunta al nodo señalado por p2 original

p2 =p2-gt;next;

}//Mover p2 hacia atrás un nodo

if(p1-gt;idlt;=p2-gt;id)

{

if(cabeza==p2)

{

p1-gt; siguiente=cabeza

cabeza=p1; ;

} // Insertar antes del primer nodo

else

{

p3-gt; >

p1-gt; next=p2;

} //Insertar después del nodo señalado por p3

}

else

{

p2-gt; next=p1;

p1-gt; next=NULL

} // Insertar hasta el final

}

n; //Aumentar el número de estudiantes en 1

coutlt;lt; "\tLa información del estudiante que ingresó se ha insertado exitosamente" lt ; lt; endl;

retorno (cabeza);

}

//------------gt;

student *Information::cancel(student *head, long int num)//Definir una función de puntero de estructura *delete() que apunta a la estructura del estudiante para eliminar la información del candidato

{.

if(head==NULL)//Si el puntero principal antes de llamar a la función secundaria está vacío

{

return(head

}

else

{

p1=head; // De lo contrario, asigna el puntero principal a p1

while(num!=p1-gt;idamp;amp;p1-gt;next!=NULL)// Encuentre el nodo que se eliminará cuando el número de boleto de admisión de estudiante señalado por p1 no es el número de boleto de admisión de estudiante ingresado y p1. es El siguiente puntero señalado no está vacío

{

p2=p1

p1=p1-gt; }/ /p2 apunta al nodo p1 señalado por el p1 original y retrocede un nodo

if (num==p1-gt; id)//Si el número de boleto de admisión de estudiante ingresado es la admisión de estudiante ticket señalado por p1 No. //Eliminar el nodo después de encontrarlo

{

if(p1==head) head=p1-gt; el puntero principal y el puntero p1 son iguales, el siguiente Asigne un nodo al puntero principal

else

p2-gt; next=p1-gt // De lo contrario, asigne el siguiente; nodo señalado por p1 al nodo señalado por p2 Omitir la información del estudiante que se eliminará

coutlt;lt;" Eliminar los estudiantes cuyo número de boleto de admisión es "lt;lt;numlt;lt;"\n" ;

n-- ;//Disminuir el número de estudiantes en 1

}

return(head);//Devolver el puntero principal

}

}

//------------gt función de búsqueda

stud;

ent *Information::find(student *head, long int num)

//Definir una función de puntero de estructura *find() que apunta a struct Student para encontrar información del candidato

{.

if(head==NULL)//Si el puntero principal antes de llamar a la función secundaria es nulo

{

coutlt;lt;" this It es una tabla vacía, ingrese primero los puntajes del examen.\n";

return(head);

}

else

{

p1=head; // De lo contrario, asigna el puntero principal a p1

while(num!=p1-gt; idamp; amp; p1-gt; next!= NULL)

//Encuentra el nodo cuando el número de boleto de admisión de estudiante señalado por p1 no es el número de boleto de admisión de estudiante ingresado y el siguiente puntero señalado por p1 no está vacío

{

p1=p1-gt; next;

}//p2 apunta al nodo p1 señalado por el p1 original y retrocede un nodo

if(num ==p1-gt ;id)//Si el número de boleto de admisión de estudiantes que desea encontrar es el número de boleto de admisión de estudiantes señalado por p1

{

coutlt;lt;" -------- ------------------------------------------ -------- --------------------\n";

coutlt;lt;"Número de boleto de admisión Nombre Género Computadora composición Principio Probabilidad Estadística Inglés C Puntuación media Puntuación total\n";

coutlt;lt;"------------------------ -------- ------------------------------------------ --------\n";

coutlt;lt;sew(8)lt;lt;p1-gt;id

lt;lt;sew(9 )lt;lt;p1-gt;nombre

p>

lt;lt;setw(8)lt;lt;p1-gt;sexo

lt;lt; setw(13)lt;lt;p1-gt;puntuación[0]

lt;lt;setw(16)lt;lt;p1-gt;puntuación[1]

lt;lt;setw(10)lt;lt;p1-gt;puntuación [2]

lt;lt;setw(9)lt;lt;p1-gt;puntuación[3]

lt;lt;setw(6)lt;lt;p1 -gt;total/4.0

lt;lt;setw(11)lt;lt;p1-gt;totallt;lt; endl;

coutlt;lt;"--- --------------------------------- ----------------- -----------------------\n";

}

else

coutlt;lt;" No se encontró el estudiante cuyo número de boleto de admisión es "lt;lt;numlt;lt;".\n"; no encontrado

return(head);

}

}

//------------Defina la función inorder() para organizar las puntuaciones totales de los candidatos de mayor a menor y generarlas

void Information:: inorder(student *head )

{

int i, k, m=0, j;

estudiante *p[Q] //Definir una matriz de estructura; punteros que apuntan a la estructura estudiante p

if(head!=NULL)//Si el puntero principal es nulo, continúa

{ m=count(head); p> coutlt;lt; "------------------------------------- ----- --------------------------\n";

coutlt;lt;"Puntuación del examen del estudiante tabla de estadísticas \n";

coutlt;lt;"-------------------------------- -------------------------------------------------- --\n";

coutlt;lt;"Número de boleto de admisión Nombre Género Composición de la computadora Principio Probabilidad Estadísticas Inglés C Puntuación promedio Clasificación de puntuación total\n";

coutlt;lt; "------- ------------------------------------------ -------- ---------------------\n";

p1=cabeza;

for(k=0;klt ; m; k )

{

p[k]=p1

p1=p1-gt;

}

for(k=0;klt;m-1;k) //Método de clasificación de selección

for(j=k 1;jlt; m;j)

if(p[k]-gt; totallt; p[j]-gt; total)

{

p2=p[ k];

p[k]=p[j];

p[j]=p2

} // Punteros ordenados de mayor a menor;

for(i=0;ilt;m;i)

{

coutlt;lt;setw(8)lt;lt;p1-gt; id

lt;lt;setw(9)lt;lt;p1-gt;nombre

lt;lt;setw(8)lt;lt;p1-gt;sexo

lt ;lt;setw(13)lt;lt;p1-gt;puntuación[0]

lt;lt;setw(16)lt;lt;p1-gt;puntuación [1]

lt;lt;setw(10)lt;lt;p1-gt;puntuación[2]

lt;lt;setw(9)lt;lt;p1 -gt;puntuación[3]

lt;lt;setw(6)lt;lt;p1-gt;total/4.0

lt;lt;setw(11)lt; lt;p1-gt;totallt ;lt;endl;

coutlt;lt;"-------------------- -----

-------------------------------------------------- \n";

}

}

}

//------------gt ; Función para encontrar el puntaje promedio de cada materia

void Información:: promedio(estudiante *cabeza)

{

int k, m; >

float arg1=0, arg2=0, arg3=0, arg4=0

if(head==NULL)//Si el puntero principal es nulo, continúa

{

coutlt;lt;" Este es un formulario vacío, ingrese primero los puntajes del examen.\n"

}

else

{

m=count(cabeza);

p1=cabeza

for(k=0;klt;m;k)

{

arg1 =p1-gt; puntuación[0];

arg2 =p1-gt; puntuación[1]; > arg3 = p1-gt; puntuación [2];

arg4 =p1-gt; puntuación

p1=p1-gt; p> }

arg1/=m; arg2/=m; arg3/=m; arg4/=m; la clase\n";

coutlt;lt;"-------------------------------- -------- ----------------------------------------\n ";

coutlt;lt;" Puntuación media de los principios de composición informática: "lt;lt;setw(7)lt;lt;arg1

lt;lt;" estadísticas de probabilidad: "lt;lt;setw( 7)lt;lt;arg2

lt;lt;" Puntuación promedio en inglés: "lt;lt;setw(7)lt;lt;arg3

lt;lt;" C Puntuación promedio: "lt;lt;sew(7)lt;lt;arg4lt;lt;endl

coutlt;lt;"------ ---------- ---------------------------------------- ---------- ------------\n";

}

}

/ /--------- ----------gt; función de guardar

información vacía:: guardar(estudiante *cabeza)

{

ofstream out( "data.txt", ios::out);

outlt;lt;count(head)lt;lt;endl; while(head!=NULL)

{ outlt;lt;head-gt;namelt;lt;"\t"

lt;lt;head-gt;idlt;lt; "\t"lt;lt;"\ t"

lt; cabeza-gt;

lt;lt;"\t"

lt;lt;head-gt;score[0]lt;lt;"\t"

lt;lt;head-gt; puntuación[1]lt;lt;"\t"

lt;lt;head-gt;puntuación[2]lt;lt;"\t"

lt;lt; cabeza-gt; puntuación[3]lt; "\t"

lt; cabeza-gt; siguiente;

}

}

//————————————gt; p>estudiante *Información:: Leer()

{ int i=0

p1=p2=(estudiante *)malloc(LEN); head=NULL;

ifstream in("data.txt",ios::out);

ingt;gt;i; =0){coutlt;lt;"Los datos en el archivo data.txt están vacíos, ingrese los datos primero.

"lt;lt;endl; return 0;}

else {

coutlt;lt;" ……………………………………………… …………………………………………”lt;lt;endl;

for(;igt;0;i--)

{ p1 =(estudiante *)malloc(LEN);

cingt;gt;st.namegt;gt;st.idgt;gt;st.sex

gt;gt;st.score [0]gt;gt;st.score[1]gt;gt;st.score[2]gt;gt;st.score[3]

gt;gt;st.total p>

strcpy(p1-gt; nombre, st.nombre);

p1-gt; id=st.id; sexo, st.sexo);

p1-gt; puntuación[0]=st.score[0]

p1-gt; puntuación[1]=st.score[ 1]

p1-gt; puntuación[2]=st.puntuación[2]; /p >

p1-gt; total=st.total;

if(n==0)head=p1; // Si se ingresa el primer grupo de información del examen del estudiante, asigne el puntero. p1 al encabezado del puntero

else p2-gt; next=p1; // De lo contrario, asigna p1 al siguiente puntero de la estructura apuntada por p2

p2=p1; / Asigna el puntero p1 al puntero p2

n; //Aumenta el valor de n en 1

//Muestra los datos leídos

coutlt;lt; " "lt;lt;p1 -gt;namelt;lt;"\t"

lt;lt;p1-gt;idlt;lt;"\t"lt;lt;"\t"

lt ;lt;p1-gt;sexlt;lt;"\t"

lt;lt;p1-gt;score[0]lt;lt;"\t"

lt ;lt;p1-gt;puntuación[1]lt;lt;"\t"

lt;lt;p1-gt;puntuación[2]lt;lt;" \t"

lt; lt; p1-gt; puntuación[3]lt; lt; "\t"

lt; lt; p1-gt; totallt; lt; endl ;

coutlt;lt;" ………………………………………………………………………………………………… ………"lt;lt;endl;

//

}

coutlt;lt;" Los datos se han leído correctamente.

"lt; lt; endl;

p2-gt; next=NULL;

return (head);

}

}

//---------------------------------gt; función principal. >

int main(void)

{

Persona de información

estudiante *head=NULL

char str[; 10];

int flag=0;

int elección;

long int

head=persona.Read() ;

p>

do{

cout< ━━━━━━━━┓";

coutlt;lt;"┃ Rendimiento de los estudiantes interfaz del menú principal del sistema de gestión┃";

coutlt;lt;"┃ Leer datos Por favor ingrese el número cero┃";

coutlt;lt;"┣━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━┫";

coutlt;lt;"① . Ingrese las puntuaciones de los estudiantes┃";

coutlt;lt;"┃ ②.Mostrar las puntuaciones de los estudiantes ┃";

coutlt;lt; "┃ ③ Ordenar puntuaciones estadísticas┃";

coutlt;lt; "┃ ④. Buscar puntuaciones de los estudiantes┃";

coutlt;lt;"┃ ⑤.Agregar puntuaciones de los estudiantes┃"; ;"┃ ⑥.Eliminar puntuaciones de estudiantes┃";

coutlt;lt;"┃ ⑦. Guardar y salir del sistema ┃";

coutlt;lt;" ━━━━ ━━━━━┛";

coutlt;lt;"Por favor, introduzca su elección (1--7): ( )\b\b";

cingt;gt; str;

if(atoi(str)gt;7 || atoi(str)lt;1)

coutlt;lt;"Lo sentimos, ¡ingrese del 1 al 7 estos números! !\n";

else

{

elección=atoi(str);

cambiar (elección)

{

caso 1:

head=person.creat();

descanso

caso 2:

persona.salida(cabeza);

descanso

caso 3:

persona.inorder(cabeza); p> person.average(head);

coutlt;lt;" El número de estudiantes que realizan el examen es: "lt;lt; person.count(head)lt;lt; ;

break;

caso 4:

coutlt;lt;" Ingrese el número de boleto de admisión (8 dígitos) que está buscando: ";

hacer{

cingt; str;

if(atol(str)gt; 99999999 || atol(str)lt; 1)

p>

coutlt;lt;"¡¡¡Lo sentimos, ingrese la entrada correcta!!!\n"

else

{i=atol(str) ); bandera=1; }

}mientras(bandera==0);

bandera=0;

descanso;

caso 5:

cabeza=persona.insert(cabeza);

persona.salida(cabeza); /p>

break;

caso 6:

coutlt;lt;" Ingrese el número del boleto de admisión (8 dígitos) que desea eliminar: ";

hacer{

cingt;gt;str;

if(atol(str)gt;99999999 || atol(str)lt;1)

coutlt;lt;"Lo siento, ingrese la entrada correcta!!!h\n";

else

{i=atol(str); /p>

} while (bandera==0);

bandera=0;

cabeza=persona.cancel(cabeza, i