Utilice lenguaje C para implementar el almacenamiento secuencial de tablas lineales (creación, inserción, eliminación y búsqueda)
//Diseño de cursos en C---Sistema de gestión del desempeño estudiantil
#include lt;stdio.hgt;
#include lt;string.hgt;
#include lt;iostream.hgt;
#include lt;stdlib.hgt;
#include lt;windows.hgt;
typedef struct Studentinfo //Definición de estructura
{
int num; //Número de identificación del estudiante
char name[64] //Nombre
int sex; //Género, 1 es masculino, 0 es femenino
float math; //Matemáticas
float english; > float politic; //Política
float chino; //Chino
float total; //Puntuación total
struct Studentinfo *next;
}ESTUDIANTE;
#define FILENAME "D:\\1.txt"
//Definir el archivo de base de datos predeterminado
#define DELAYTIME 1500
//Mostrar información, retraso
void create_menu();
ESTUDIANTE * new_student();
ESTUDIANTE* create_linkbyfile( char *);
ESTUDIANTE *del_info(ESTUDIANTE *);
int save_info(char *, ESTUDIANTE *, int);
int find_infile_printf(char * ) ;
int pri_whole_link(ESTUDIANTE *);
ESTUDIANTE* printf_sort(ESTUDIANTE *);
void free_link(ESTUDIANTE *);
void main() //Función principal
{
create_menu();
}
ESTUDIANTE * revés(ESTUDIANTE * cabeza )
//Función: invertir el orden de la lista vinculada
//Parámetro: puntero principal al nodo principal de la lista vinculada
{
ESTUDIANTE *ptemp, *p1;
if(head==NULL)
{
devuelve 0;
}
p1=head; //p1 hace que siempre apunte al primer nodo en la clasificación, con el valor inicial siendo head, y head hace que siempre apunte al último nodo en la clasificación
while(head-gt; next!=NULL)//Este bucle ordena ptemp
{
ptemp=head-gt //ptemp apunta a; sin clasificar El primer nodo en buen estado
head-gt; next=ptemp-gt; next; //
ptemp-gt;
1; //ptemp también se ordena y ptemp se convierte en el primer nodo ordenado
p1=ptemp //Deje que p1 vuelva a ser el primer nodo ordenado
}
<; p> return p1; // El nodo principal es el primer nodo}
void create_menu()
// Función: Menú de funciones de salida, proporciona humanos -interfaz de computadora
{
char menu_Num;
ESTUDIANTE *head=NULL;
char ch;
char nombre_archivo[256];
while(1)
{
sistema( "cls");
coutlt;lt ;"\t\tSistema de gestión del rendimiento estudiantil\n";
coutlt;lt;"######### ################ ################\n";
coutlt;lt;"# \t\t 1. Agregar información del estudiante\t\t #\n" ;
coutlt;lt;"#\t\t 2. Cargar base de datos\t\t #\n";
coutlt;lt;"#\t\t 3. Eliminar información del estudiante\t\t #\n";
coutlt;lt;"#\t\t 4. Guardar información del estudiante\t\t #\n";
coutlt;lt;"#\t\t 5. Consulta de base de datos\t\t #\n";
coutlt;"#\t\t 6. Salida del pedido original\t\t # \n";
coutlt;lt;"#\t\t 7. Salida ordenada\t\t #\n ";
coutlt;lt;"#\t\ t 8. Salir\t\t\t #\n";
coutlt;lt;"##### ################## #################\n";
coutlt; lt; "Por favor ingrese el número de operación:";
cingt; gt; menu_Num;
cambiar (menu_Num)
{
caso '1':
free_link(head); espacio de lista vinculada
head=new_student(); //Agregar información del estudiante
break;
case '2':
free_link (head); //Liberar el espacio de la lista vinculada
coutlt;lt;"Ingrese la ruta del archivo de base de datos que se va a cargar" lt;lt;endl;
cingt;gt ;file_name;
head=create_linkbyfile(file_name);//Leer archivo de datos
if (head! =NULL)
{
coutlt;lt;"database"lt;lt;file_namelt;lt;"Loaded"lt;lt;endl;
Dormir(DELAYTIME);
}
break;
case '3':
del_info(head); //Eliminar mensaje de los estudiantes
break;
c
ase '4': //Guardar información del estudiante
if (head==NULL)
{
coutlt;lt;"Primero genere la información del estudiante" lt; lt; endl;
Dormir(DELAYTIME
}
else
{
coutlt; ;lt;"¿En qué archivo de base de datos desea guardar la información del estudiante?";
cingt;gt;file_name;
coutlt;lt;"Seleccione el método para guardar: 0 agregar al archivo 1 al final sobrescribe el archivo\n";
cingt;gt;menu_Num;
if(save_info(file_name, head, menu_Num-'0')== 0)//0 significa Agregar, 1 significa sobrescribir
{
coutlt;lt;"Error al guardar información\n";
}
else
else
p>
{
coutlt;lt;"Los datos se han guardado en"lt;lt;file_namelt;lt ;endl;
Dormir(DELAYTIME);
}
}
descanso
case '5; ':
find_infile_printf(FILENAME); //Consulta de base de datos
break;
case '6': //información de salida de la secuencia original
pri_whole_link(head);
coutlt;lt;"¿volver al menú principal? S/N\t";
hacer
{
cingt;gt;ch;
} while(ch !='Y'amp;amp;ch!='y');
descanso;
case '7': //Ordenar información de salida
do
{
if((head=printf_sort(head))==NULL)
{
coutlt;lt;" Base de datos no cargada"lt;lt;endl;
Suspender(DELAYTIME);
pausa ;
}
else
{
coutlt;lt;"¿Elegir otra forma de ordenar? Y/N\t";
cingt;gt;ch;
}
} while(ch=='Y'||ch==' y');
break;
case '8':
free_link(head); // Libera el espacio de la lista vinculada
break;
predeterminado:
coutlt; ¡Por favor vuelve a entrar! "lt;lt;endl;
Dormir(DELAYTIME);
descanso;
}
}
}
ESTUDIANTE * nuevo_st
udent()
//Función: crear información del estudiante (a través de una lista vinculada)
//Valor de retorno: puntero del nodo principal
{
ESTUDIANTE *pnew, *p, *head;
float *pfloat;
char
head=NULL; > hacer
{
system("cls");
pnew=(ESTUDIANTE *)malloc(tamañode(ESTUDIANTE)*1);
coutlt;lt;"Por favor ingrese el número de estudiante del estudiante (0 significa cancelar): ";
cingt;gt;pnew-gt;num;
if(0gt ;=pnew-gt;num)
{
break;
}
coutlt;lt;"Por favor ingrese el nombre del estudiante : ";
cingt;gt;pnew-gt;nombre;
mientras(1)
{
coutlt;lt; "Por favor ingrese el género del estudiante: 0/1\t";
cingt;gt;pnew-gt;sex;
if(pnew-gt;sexamp;amp;pnew- gt;sex-1)
{
coutlt;lt;"La entrada de género es incorrecta, 0 significa mujer, 1 significa hombre, vuelva a ingresar"lt;lt;endl ;
}
más
{
descanso
}
}
coutlt;lt;"Ingrese los puntajes de los estudiantes en matemáticas, inglés, política y chino en orden:"lt;lt;endl;
for(pnew-gt; total=0,pfloat=amp ;pnew-gt;math;pfloatlt;amp;pnew-gt;math 4;)
{
cingt;gt;*pfloat;
if( *pfloatlt; 0|| p>
}
else
{
pnew-gt; total =*pfloat
pfloat;
}
}
if(head==NULL)
{
head=pnew;
}
else
{
p-gt; p>
}
p=pnew;
pnew-gt;next=NULL;
coutlt;lt;"###### ############# #######La información del estudiante ha sido generada#######################\ n";
coutlt; lt;"¿Crear la información de otro estudiante? S/N\t";
cingt;gt;c
h;
} while(ch=='Y'||ch=='y');
return head;
}
ESTUDIANTE* create_linkbyfile(char *filename)
//Función: leer el archivo y crear una lista vinculada
//Parámetros: si el nombre del archivo no está vacío, abre el archivo , Si el nombre del archivo está vacío, se requiere la ubicación del archivo
//El siguiente de todos los nodos en la lista vinculada creada se modifica para que apunte al siguiente nodo en la dirección física
{
system("cls");
ARCHIVO *fp;
ESTUDIANTE *head, *ptemp, *pnew; NULL; //Inicializa el encabezado para que esté vacío
if(filename==NULL)//Si el nombre del archivo está vacío, se requiere la dirección absoluta del archivo
{
char file_name[ 256];
coutlt;lt;"Ingrese la ruta al archivo de base de datos: "lt;lt;endl;
cingt;gt;file_name;
if (NULL==(fp=fopen(file_name, "rb")))
{
coutlt;lt;"Error en la conexión a la base de datos\n ";
devuelve 0;
}
}
más
{
if(NULL==(fp =fopen(nombre de archivo, "rb")))
{
coutlt;lt;"Error en la conexión a la base de datos\n";
devuelve 0;
coutlt;lt;"Error en la conexión a la base de datos\n";
devuelve 0;
p>}
}
for(ptemp=NULL;;)
{
pnew=(ESTUDIANTE *) malloc(tamañode(ESTUDIANTE)*1);
if(fread(pnew,sizeof(STUDENT),1,fp)!=NULL)
{
if(ptemp!=NULL)
{
ptemp-gt; siguiente=pnew
}
más
{
}
ptemp=pnuevo
}
más
{
if(ptemp!=NULL)
{
ptemp-gt; next=NULL;
}
else
{
head=NULL
}
gratis(pnew);
descanso;
}
}
fclose(fp);
retorno cabeza;
p>
}
ESTUDIANTE *del_info(ESTUDIANTE *head)
//Eliminar el nodo de la lista enlazada según el número de estudiante
{
system("cls");
ESTUDIANTE *p1, *p2
int num;
if (head==NULL)
{
coutlt;lt;"Base de datos no cargada"lt;lt;endl;
Suspender(DELAYTIME );
return 0;
}
coutlt; "Ingrese el número de estudiante que desea eliminar:";
cingt; gt; num;
for(p1=cabeza; p1!=NULL;)
{
if(p1-gt; num ==num )//Buscar
{
if(p1==head)//El nodo que se eliminará es el nodo principal
{
cabeza=p1-gt; siguiente
}
más
{
p2-gt; p1-gt ;siguiente;
}
coutlt;lt;"¡¡Eliminado correctamente!!";
}
p2=p1 ;
p>p1=p1-gt; siguiente;
}
regresar cabeza; >int save_info(char *filename, STUDENT *head, int flag)
//Función: escribir la lista vinculada al final del archivo como binario
//Parámetros:
//1 .filename nombre de archivo, dirección absoluta
//2.head apunta al nodo principal de la lista vinculada
//3.flag 0 agrega o 1 sobrescribe los datos
//Valor de retorno: 0 si falla
{
system("cls"); ARCHIVO *fp;
ESTUDIANTE *p;
char openmethod[8]
if(flag==0)
{
strcpy(openmethod," ab "); //Agregar
}
else
{
strcpy(openmethod, "w"); //Sobrescribir
}
if(NULL==(fp=fopen(filename, openmethod)))//
{
coutlt; "Error en la conexión de la base de datos"; lt;
Dormir(DELAYTIME); >
}
else
{
for(p=head; p; p=p-gt; next)
{
if(( fwrite(p,sizeof(ESTUDIANTE),1,fp))==NULL)
{
coutlt;lt;" Error al crear la base de datos"lt;lt;endl;
p>return 0;
}
}
}
f
close(fp);
return 1;
}
int find_infile_printf(char *nombre de archivo)
//Función: Según aprendiendo Número y nombre para consultar a un estudiante
//Parámetro: archivo de base de datos de nombre de archivo
//Valor de retorno: Devuelve 0 en caso de error
//Buscar archivos directamente, la desventaja es que es lento
// También puede crear una lista vinculada basada en el archivo primero y luego buscar en la lista vinculada. La desventaja es que si el archivo es grande, se necesita. ocupa mucha memoria
{
system("cls");
ARCHIVO *fp
ESTUDIANTE stu
p>int num;
char stu_name[64] ;
char ch;
if(filename==NULL)
{
devolver 0;
}
hacer
{
memset(stu_name, 0, sizeof(stu_name));
coutlt; lt; "¿Consultar número o nombre de ciencia? 1 Consultar número de estudiante 0 Consultar nombre";
//flag=1 para consultar según el estudiante número, bandera=0 para consultar según el nombre
cingt;gt; num;
if(num==1)
{
coutlt;lt;"Ingrese el número de estudiante a consultar:";
cingt; num;
coutlt; número "lt; lt; numlt; lt;"..." lt; lt; endl;
}
else if(num==0)
{
coutlt;lt;"Ingrese el nombre a consultar:";
cingt;gt;stu_name;
coutlt;lt;"Estamos buscando estudiantes llamados "lt;lt;stu_namelt;lt;"..."lt;lt;endl ;
}
else
{
coutlt;lt;"Error de entrada"lt;lt;endl;
devuelve 0;
}
if(NULL==( fp=fopen(nombre de archivo, "rw")))
{
coutlt;lt;"Error de conexión a la base de datos\n";
devuelve 0;
}
else
{
while(fread(amp;stu,sizeof(ESTUDIANTE),1,fp)!=NULL )
{
if(strcmp(stu. nombre, stu_name)==0||stu.num==num)
{
coutlt;lt;"ID del estudiante\tNombre\tGénero\tMatemáticas\tInglés \tPolitics\tChino\tPuntuación total\n";
// Genera toda la información del estudiante
coutlt;lt;stu.numlt;lt;"\t" lt;lt;stu.namel
t;lt;"\t"lt;lt;stu.sexlt;lt;"\t"lt;lt;stu.mathlt;lt;"\t"lt;lt;stu.englishlt;lt;"\t" lt;lt;stu.politiclt;lt;"\t"lt;lt;stu.chineselt;lt;"\t"lt;lt;stu.totallt;lt;endl;
//No Agregar pausa; puede admitir múltiples índices de los mismos datos
}
}
}
coutlt;lt;"### #######################Consulta completada########################\ n";
coutlt;lt;"¿Consultar la información de otro estudiante? S/N\t";
cingt;gt;ch;
} while( ch=='Y'||ch=='y');
fclose(fp);
devuelve 1;
}
int pri_whole_link(STUDENT *head)
//Función: muestra la información del estudiante de toda la lista vinculada
//Parámetro: puntero del nodo principal, si el encabezado está vacío, return vacío
{
system("cls");
ESTUDIANTE* p;
if (head== NULL)
{
coutlt;lt;"Base de datos no cargada"lt;lt;endl;
Dormir(DELAYTIME);
devolver 0
}
coutlt;lt;"Número de estudiante\tNombre\tGénero\tMatemáticas\tInglés\tPolítica\tChino\tPuntuación total\n "; (p=cabeza; p; p=p-gt; siguiente)
{
coutlt;lt;p-gt;numlt;"\t"lt;lt; p-gt;namelt;lt;"\t"lt;lt;p-gt;sexlt;lt;"\t"lt;lt;p-gt;mathlt;lt; "\t"lt;lt;p- gt;englishlt;lt;"\t"lt;lt;p-gt;politiclt;lt;"\t"lt;lt;p-gt;chineselt;lt;"\ t"lt;lt;p-gt; totallt;lt;endl;
}
return 1;
}
ESTUDIANTE * printf_sort(ESTUDIANTE *cabeza)
//Función: ordenar la lista vinculada según el número de estudiante | calificación de una determinada materia | calificación total y luego generar
//Parámetro: puntero principal de la lista vinculada principal, si es principal está vacío, devuelve vacío
//Valor de retorno: devuelve el puntero del nodo principal de la nueva lista vinculada
{
system("cls") ;
ESTUDIANTE *p1, *p2, *ptemp, *pfinished=NULL;
char num;
char flag
if ( head==NULL)
{
return 0;
}
coutlt;lt;"
Seleccione y ordene según 0. Puntuación de matemáticas 1. Puntuación de inglés 2. Puntuación política 3. Puntuación de chino 4. Puntuación total\n";
while(1)
{
cingt;gt;num;
if(numgt;'4'||numlt;'0')
{
coutlt; lt; "Ingreso incorrecto, vuelva a ingresar 0~4"lt;lt;endl;
}
else
{
break ;
}
}
coutlt;lt;"¿Salida en orden ascendente/descendente? 0. Orden descendente 1. Orden ascendente";
while(1)
{
cingt; gt; flag;
if (flaggt ;'1'||flaglt;'0')
{
coutlt;lt;"Entrada incorrecta, vuelva a ingresar 0~1"lt;lt;endl ;
}
más
{
descanso
}
}
for(p1=head; p1-gt; next!=pfinished;)// Ordena la lista enlazada de mayor a menor (aquí se utiliza el método de la burbuja)
//p1 hace que siempre apunte al nodo principal, pfinished hace que siempre apunte al nodo más frontal que ha sido ordenado
//ptemp sirve como intermediario para guardar el nodo anterior de p2
{
for(p2=p1;p2-gt;siguiente!=pfinalizado;)
{
if(*(amp;(p2-gt; math ) num-'0')lt *(amp; (p2-gt; next-gt; math) num-'0'))// El valor de p2 es menor que el valor de p2-gt; exchange ptemp p2 p2- gt; next
{
if(p2==p1)//El nodo principal debe intercambiarse
{
p1=p2 -gt; siguiente
p2-gt; siguiente=p1-gt; siguiente
p1-gt;
ptemp=p1;
}
else
{
ptemp-gt; siguiente=p2-gt;
ptemp=p2-gt; siguiente
p2-gt; siguiente=ptemp-gt; siguiente
ptemp-gt; /p>
}
}
else//No se requiere intercambio, luego p2 y ptemp avanzan 1 dígito
{
ptemp=p2;
p>p2=p2-gt;
}
}
pfinalizado; p2;
}
if(flag=='1')
{
p1=reverse(p1);
}
pri_whole_link(p
1);
coutlt;lt;"#########################Se muestra la información###### ##################\n";
return p1;
}
void free_link ( ESTUDIANTE *cabeza)
//Liberar espacio de lista enlazada, si es cabeza, no hacer nada
{
ESTUDIANTE *p1, *p2;
for(p1=head; p1; p1=p2)
{
p2=p1-gt; //Guardar primero, de lo contrario
free(p1); //p1-gt después de liberar; se pierden los siguientes datos
}
}