(contenido del archivo ahora añadido)
(versión: 2.0, modificada: ordenar, almacenar, cargar)
Requerir:
Primero, un análisis simple del tema: gestión de datos, solo necesita una lista enlazada simple para completar. Los métodos de administración incluyen entrada (agregar los datos escritos desde el teclado al final de la lista enlazada), almacenamiento (almacenar los datos del estudiante del programa en un archivo), carga (cargar los datos del estudiante en el archivo al programa), modificación (modificar un elemento en los datos del estudiante), insertar (insertar los datos del estudiante en la lista vinculada), eliminar (eliminar los datos del estudiante), buscar (encontrar los datos del estudiante a través del número de estudiante), ordenar (número de estudiante de pequeño a clasificación grande), mostrar (mostrar todos los datos de los estudiantes).
La dificultad es muy clara: 1. Los datos de archivos y programas se transfieren entre sí. 2. Clasificación de listas enlazadas.
1. Programación modular.
Para facilitar la modificación y comprensión del código, recomiendo la programación modular en el diseño de este curso.
Este tipo de programa grande tiene al menos líneas 500. Si solo se coloca en un archivo, la profundidad será demasiado profunda y el código será largo y maloliente.
Para lograr la programación modular, aquí hablaré sobre la implementación simple de la programación modular.
A. Crear el archivo de encabezado
Muchos estudiantes universitarios ignoran la importancia de los archivos de encabezado. A través de un archivo de encabezado, podemos usar una estructura en dos archivos c (totalmente reflejados en el diseño de este curso). Con el archivo de encabezado, si necesita usar el código que ha escrito hasta ahora, puede llamarlo rápidamente a través del archivo de encabezado. El archivo de encabezado se escribe de la siguiente manera:
El más importante de ellos es la parte rodeada por el cuadro rojo. Este es un contenido indispensable de cada archivo de encabezado. El contenido después de ifndef y define es el nombre del archivo de encabezado. Se ingresa el formato. Tenga en cuenta que hay dos guiones bajos al frente.
Declare las funciones en el archivo c en el archivo de encabezado y use la estructura en el archivo de encabezado, lo que reducirá en gran medida la cantidad de escritura del archivo c.
B. Referencias en archivos c
El método de referencia es el siguiente
Utilice este formato para hacer referencia a los archivos de encabezado.
2. Visualización general del código
El código general se pone aquí primero y se explicará uno por uno más adelante.
código de archivo main.cpp
#include <stdio.h>
#include "line_list.h" //线性表操作头文件
#include <stdlib.h>
extern struct Student;
//名称：学生数据管理。
//内容：录入，存储，装入，修改，插入，删除，查找，排序，显示。
//数据结构：线性表。
//数据对象：班或系的学生记录。
//学生记录：学号，姓名，年龄，性别，家庭住址，入学时间，家庭电话号码。
int main()
{
struct Student* head; //学生数据的头指针。
int state= -1; //初始状态，以进入和在选择操作中使用。
head = (struct Student* )malloc(150);
head->pNextNode=NULL;
printf("欢迎使用本学生数据管理系统");
while(state!=0)
{
printf("请输入您想要进行的操作的数字序号：0.退出 1.录入 2.修改 3.插入 4.删除 5.查找 6.排序 7.显示 8.装入 9.存储\n");
scanf("%d",&state);
getchar(); //吃回车
while(state==1)
{
List_LuRu(head); //将尾指针放进去，新建链表来改变尾指针，最后将尾指针赋值回去。
printf("如果需要继续录入，则输入1；退出录入，则输入-1。\n");
scanf("%d",&state);
getchar();
}
while(state==2)
{
int lin,col; //输入序号和列数以修改
List_XianShi(head); //显示帮助输入
printf("请问您要修改序号几的第几列内容？(一次修改一个内容，空格隔开输入)\n");
scanf("%d %d",&lin,&col);
List_XiuGai(head,lin,col); //修改函数
printf("如果需要继续修改，则输入2；退出修改，则输入-1。\n");
scanf("%d",&state);
}
while(state==3)
{
int lin; //输入序号
List_XianShi(head); //显示帮助输入
printf("请问您要插入到第几序号后:\n");
scanf("%d",&lin);
List_ChaRu(head,lin); //插入函数
printf("如果需要继续插入，则输入3；退出插入，则输入-1。\n");
scanf("%d",&state);
}
while(state==4)
{
int lin;
List_XianShi(head);
printf("请问您要删除第几序号的学生数据：");
scanf("%d",&lin);
List_ShanChu(head,lin); //删除函数
printf("如果需要继续删除，则输入4；退出删除，则输入-1。\n");
scanf("%d",&state);
}
while(state==5) //查找
{
int aim; //查找方式
printf("请问您是要什么方式查找数据？\n");
printf("1.学号 2.序号\n");
scanf("%d",&aim);
List_ChaZhao(head,aim); //查找函数，输入为查找方式
printf("如果需要继续查找，则输入5；退出查找，则输入-1。\n");
scanf("%d",&state);
}
while(state==6) //排序
{
printf("正在进行学号排序in....（若数据过多，则缓冲时间会比较长）\n");
List_PaiXv(head);
printf("如果需要继续排序，则输入6；退出排序，则输入-1。\n");
scanf("%d",&state);
}
while(state==7)
{
List_XianShi(head); //将头指针放进去，以获得整个链表的所有信息。
printf("如果需要继续显示，则输入7；退出显示，则输入-1。\n");
scanf("%d",&state);
}
while(state==8)
{
printf("正在装入data中。。。。。\n");
List_fLuRu(head);
printf("录入成功！\n");
state=-1;
}
while(state==9)
{
printf("正在储存数据到sum中。。。。\n");
List_fCunChu(head);
printf("存储成功！\n");
state=-1;
}
}
}código line_list.cpp
#include <stdio.h>
#include <stdlib.h>
#include "line_list.h"
#include <string.h>
void List_LuRu(struct Student *head)
{
struct Student* Temp;
struct Student* Temp2;
Temp2 = head;
while(Temp2->pNextNode!=NULL)
{
Temp2=Temp2->pNextNode;
}
printf("请输入学生的学号 ,姓名 ,年龄 ,性别(b/g) ,家庭住址 ,入学时间(xx/xx/xx) 家庭电话号码。(中间空格隔开)\n");
Temp = (struct Student*)malloc(150); //新建一个动态链表
scanf("%s %s %s %s %s %s %s",Temp->ID,Temp->name,Temp->age,Temp->sex,Temp->address,Temp->Time,Temp->number);//该表内容的输入
Temp2->pNextNode=Temp; //将目前尾指针的指向该链表
Temp2=Temp;
Temp2->pNextNode=NULL; //尾指针的下一项指向NULL
}
void List_XianShi(struct Student *head) //显示函数
{
int temp=0;
struct Student* List;
List = head->pNextNode; //初始指向头指针下一个链表。头指针是空的
while(List!=NULL) //只要List不是空的，就执行
{
temp=temp+1;
printf("序号%d: ",temp);
printf("%s %s %s %s %s %s %s\n",List->ID,List->name,List->age,List->sex,List->address,List->Time,List->number);
List=List->pNextNode; //指向下一个List
}
}
void List_XiuGai(struct Student *head,int lin,int col) //修改函数
{
struct Student* List;
List=head->pNextNode;
int Temp=lin;
while(lin>1) //指针不断指向下一个，直到找到目标指针
{
lin=lin-1;
List=List->pNextNode;
}
if(lin==1) //找到了
{
if(List==NULL) //如果是空指针，报错
{
printf("请输入合法的序号。\n");
}
else if(col==1)
{
printf("定位到%d号的学号\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->ID);
}
else if(col==2)
{
printf("定位到%d号的姓名\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->name);
}
else if(col==3)
{
printf("定位到%d号的年龄\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->age);
}
else if(col==4)
{
printf("定位到%d号的性别\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->sex);
}
else if(col==5)
{
printf("定位到%d号的地址\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->address);
}
else if(col==6)
{
printf("定位到%d号的入学时间\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->Time);
}
else if(col==7)
{
printf("定位到%d号的电话号码\n",Temp);
printf("请输入您的修改后的内容:");
scanf("%s",List->number);
}
else //若col不在范围内，报错
{
printf("请输入合法的列号\n");
}
}
else //如果是负或0的序号
{
printf("请输入合法的序号\n");
}
}
void List_ChaRu(struct Student *head,int lin) //插入函数
{
struct Student* List_begin; //前一个
struct Student* List_end; //后一个
struct Student* Temp; //中间插的
List_begin=head->pNextNode;
List_end=List_begin->pNextNode;//将后一个指针接于前一个指针后
while(lin>1) //寻找目标位置
{
lin=lin-1;
List_begin=List_begin->pNextNode;
List_end=List_begin->pNextNode;
}
if(lin==1) //找到了
{
Temp=(struct Student*)malloc(150); //创建新链表
printf("请输入学生的学号 ,姓名 ,年龄 ,性别(b/g) ,家庭住址 ,入学时间(xx/xx/xx) 家庭电话号码。(中间空格隔开)\n");
scanf("%s %s %s %s %s %s %s",Temp->ID,Temp->name,Temp->age,Temp->sex,Temp->address,Temp->Time,Temp->number);
List_begin->pNextNode=Temp;//插在目标位置
Temp->pNextNode=List_end;
}
else //序号为0或负，报错
{
printf("输入不合法！\n");
}
}
void List_ShanChu(struct Student* head,int lin)
{
struct Student* List_begin; //前一个
struct Student* Temp; //删除目标
Temp=head->pNextNode;
List_begin=head;
while(lin>1) //寻找
{
lin=lin-1;
List_begin=Temp;
Temp=Temp->pNextNode;
}
if(lin==1) //找到了，删除
{
List_begin->pNextNode=Temp->pNextNode; //让前一个指针指向后一个指针
printf("删除成功！\n");
}
else //序号错误
{
printf("输入非法序号\n");
}
}
void List_ChaZhao(struct Student* head,int aim) //目前只有两种查找方式
{
struct Student* List;
char ID[15];
int sum; //查找的序号或者学号
int Temp; //临时存储信息
List=head->pNextNode;
if(aim==0)
{
printf("请输入查找的序号：");
scanf("%d",&sum);
Temp=sum;
while(sum>1) //寻找查找序号目标
{
List=List->pNextNode;
sum=sum-1;
}
if(sum==1) //找到了
{
printf("序号%d: ",Temp);
printf("%s %s %s %s %s %s %s\n",List->ID,List->name,List->age,List->sex,List->address,List->Time,List->number);
}
else //没找到
{
printf("输入序号不合法\n");
}
}
else if(aim==1) //寻找查找学号目标
{
printf("请输入查找的学号：");
scanf("%s",ID);
while(List!=NULL)
{
if(strcmp(List->ID,ID)!=0)
{
List=List->pNextNode;
}
else
{
break;
}
}
if(strcmp(List->ID,ID)==0) //找到了
{
printf("学号%s: ",ID);
printf("%s %s %s %s %s %s %s\n",List->ID,List->name,List->age,List->sex,List->address,List->Time,List->number);
}
else //没找到
{
printf("没有该学号的数据！\n");
}
}
else //查找方式错误
{
printf("输入查找目标不合法\n");
}
}
void List_PaiXv(struct Student* head)
{
//本代码将采用简单的冒泡排序法.
struct Student* List_begin_1; //第一轮循环前一个
struct Student* List_begin_2; //第二轮循环前一个
struct Student* List_in_2; //第二轮循环中间一个
struct Student* List_end_2; //第二轮循环后一个
List_begin_1 = head;
while(List_begin_1->pNextNode->pNextNode!=NULL) //以下为简单的冒泡排序法
{
List_begin_2 = head;
List_in_2 = List_begin_2->pNextNode;
List_end_2 = List_in_2->pNextNode;
while(List_end_2!=NULL)
{
if(strcmp(List_in_2->ID,List_end_2->ID)>0)
{
List_begin_2->pNextNode=List_end_2;
List_in_2->pNextNode=List_end_2->pNextNode;
List_end_2->pNextNode=List_in_2;
List_in_2 = List_begin_2->pNextNode;
List_end_2 = List_in_2->pNextNode;
}
List_begin_2=List_begin_2->pNextNode;
List_in_2=List_in_2->pNextNode;
List_end_2=List_end_2->pNextNode;
}
List_begin_1=List_begin_1->pNextNode;
}
}
void List_fLuRu(struct Student* head) //装入函数
{
FILE* fp; //文件指针
int n=0; //数组的位置
int state=0;//链表的位置
char ch; //录入字符
struct Student* List;//链表指针
struct Student* Temp;
List=(struct Student*)malloc(150);
head->pNextNode=List;
if((fp=fopen("C:\\Users\\池上桜\\Desktop\\学习\\课设\\Project\\data.txt","r+"))==NULL) //打开文件
{
printf("No file!\n");
exit(0);
}
while(!feof(fp))
{
ch=fgetc(fp);
if(ch!='\n')//换行
{
if(ch!=' ') //空格切换一次链表位置
{
if(state==0) //链表在ID位置，以下同理
{
List->ID[n]=ch;
List->ID[n+1]='\0';
}
else if(state==1)
{
List->name[n]=ch;
List->name[n+1]='\0';
}
else if(state==2)
{
List->age[n]=ch;
List->age[n+1]='\0';
}
else if(state==3)
{
List->sex[n]=ch;
List->sex[n+1]='\0';
}
else if(state==4)
{
List->address[n]=ch;
List->address[n+1]='\0';
}
else if(state==5)
{
List->Time[n]=ch;
List->Time[n+1]='\0';
}
else if(state==6)
{
List->number[n]=ch;
List->number[n+1]='\0';
}
else
{
printf("格式有误！");
exit(0);
}
n++;
}
else
{
state=state+1;
n=0;
}
}
else
{
Temp = (struct Student*)malloc(150);
List->pNextNode=Temp;
List=Temp;
List->pNextNode=NULL;
n=0;
state=0;
}
}
fclose(fp);
}
void List_fCunChu(struct Student* head)
{
FILE* fp; //文件指针
struct Student* List;//链表指针
List=head->pNextNode;
if((fp=fopen("C:\\Users\\池上桜\\Desktop\\学习\\课设\\Project\\sum.txt","w+"))==NULL) //打开文件
{
printf("No file!\n");
exit(0);
}
while(List->pNextNode!=NULL)
{
fputs(List->ID,fp);
fputc('\0',fp);
fputs(List->name,fp);
fputc('\0',fp);
fputs(List->age,fp);
fputc('\0',fp);
fputs(List->sex,fp);
fputc('\0',fp);
fputs(List->address,fp);
fputc('\0',fp);
fputs(List->Time,fp);
fputc('\0',fp);
fputs(List->number,fp);
fputc('\n',fp);
List=List->pNextNode;
}
fputs(List->ID,fp);
fputc('\0',fp);
fputs(List->name,fp);
fputc('\0',fp);
fputs(List->age,fp);
fputc('\0',fp);
fputs(List->sex,fp);
fputc('\0',fp);
fputs(List->address,fp);
fputc('\0',fp);
fputs(List->Time,fp);
fputc('\0',fp);
fputs(List->number,fp);
fclose(fp);
}
código line_list.h
#ifndef __LINE_LIST_H
#define __LINE_LIST_H
struct Student {
char ID[15]; //学生学号
char name[10]; //学生姓名
char age[3]; //学生年龄
char sex[5]; //性别
char address[30]; //住址
char Time[15]; //入学时间
char number[15]; //电话号码
struct Student * pNextNode;
};
void List_LuRu(struct Student *head);
void List_XianShi(struct Student *head);
void List_XiuGai(struct Student *head,int lin,int col);
void List_ChaRu(struct Student *head,int lin);
void List_ShanChu(struct Student* head,int lin);
void List_ChaZhao(struct Student* head,int aim);
void List_PaiXv(struct Student* head);
void List_fLuRu(struct Student *head); //装入
void List_fCunChu(struct Student* head); //存储
#endifTenga en cuenta que en la última línea del archivo de encabezado, deje una línea en blanco para evitar algunos errores metafísicos.
3. Análisis de código completo
A. El código en la función principal main.cpp:
Dado que la lógica del código en main.cpp es simple, solo se necesita una columna para explicarlo claramente.
Primero, cree una lista enlazada vacía como el nodo principal. Este método de creación es el método estándar de creación de listas lineales en el libro de estructura de datos oficial, que puede facilitar muchas operaciones en el futuro (como la clasificación). Luego, deje que el siguiente elemento del la lista enlazada apunta a NULL, ya que al final del juicio, esta lista enlazada es donde se almacenan todos los datos.
Luego use scanf para recibir la operación que el usuario desea realizar, y pregunte continuamente las necesidades del usuario en el ciclo while para lograr el propósito de administrar el sistema.Se debe agregar un segundo scanf a cada segundo nivel para recibir al usuario después de usar una intención de función.
Este es aproximadamente el contenido de la función principal.
B. El código del archivo de cabecera line_list.h:
line_list.h es un archivo de encabezado simple. Lo que hay que decir aquí es la estructura interna. Aquí, la estructura no se puede renombrar como Estudiante, de lo contrario, se informará un error. Aunque no sé por qué, simplemente siga lo anterior. la práctica del código no será perturbada por la metafísica.
C. El código de la biblioteca de funciones line_list.cpp:
Analiza de arriba a abajo
A. Función de entrada
La entrada es para conectar los datos al siguiente bit de la lista enlazada actual. Por lo tanto, debe ingresarse como el nodo principal, y el bucle while encuentra el último nodo de la lista enlazada actual, y luego la lista enlazada es creado, se ingresa el contenido y la lista vinculada se conecta al último nodo, y luego apunta el siguiente bit del último nodo a NULL.
NULL se usa para juzgar la cola de la lista enlazada, lo que sin duda refleja su excelente funcionalidad aquí.
código:
B. Función de visualización
¿Por qué poner la función de visualización en una posición tan alta? Por supuesto, esto se debe a que solo con la visualización puede saber si hay algún problema con su escritura.
La función de visualización comienza después del nodo principal y muestra los datos en cada tabla hasta NULL.
C. Modificar la función
La modificación requiere que el usuario elija el contenido que se modificará, por lo que la entrada es un número de serie y un número de columna. El número de serie se refiere al número de serie de los datos en la lista vinculada actual que se muestra a través de la pantalla, y el número de columna es el objetivo de la modificación (por ejemplo, el número de estudiante es 1)
También use primero while para encontrar los datos que deben modificarse y luego use la declaración if para determinar el número de columna, que se puede modificar con precisión.
(parte)
D. Insertar función
Muestre primero la lista vinculada y pregunte cuánto debe insertarse después del número de serie. Defina los punteros de las tres listas vinculadas delantera, media y trasera en la función, y conecte los tres punteros después de encontrar la posición.
E. Función de eliminación
La operación de eliminación también requiere múltiples punteros. Después de encontrar la posición, cambie el último puntero anterior al siguiente del objetivo de eliminación, puede omitir directamente el objetivo de eliminación y finalmente liberarlo.
F. Función de búsqueda
La función de búsqueda es la más simple lógicamente y solo necesita juzgar si es consistente con el objetivo de búsqueda, por lo tanto, no la repetiré aquí.
G. Función de clasificación
En la función de clasificación, se utiliza el método de clasificación de burbujas. La implementación específica es la siguiente. En esta función, se refleja la ventaja de convertir el puntero de la cabeza en vacío. Un puntero más evita juzgar si es un puntero de la cabeza.
void List_PaiXv(struct Student* head)
{
//本代码将采用简单的冒泡排序法.
struct Student* List_begin_1; //第一轮循环前一个
struct Student* List_begin_2; //第二轮循环前一个
struct Student* List_in_2; //第二轮循环中间一个
struct Student* List_end_2; //第二轮循环后一个
List_begin_1 = head;
while(List_begin_1->pNextNode->pNextNode!=NULL) //以下为简单的冒泡排序法
{
List_begin_2 = head;
List_in_2 = List_begin_2->pNextNode;
List_end_2 = List_in_2->pNextNode;
while(List_end_2!=NULL)
{
if(strcmp(List_in_2->ID,List_end_2->ID)>0)
{
List_begin_2->pNextNode=List_end_2;
List_in_2->pNextNode=List_end_2->pNextNode;
List_end_2->pNextNode=List_in_2;
List_in_2 = List_begin_2->pNextNode;
List_end_2 = List_in_2->pNextNode;
}
List_begin_2=List_begin_2->pNextNode;
List_in_2=List_in_2->pNextNode;
List_end_2=List_end_2->pNextNode;
}
List_begin_1=List_begin_1->pNextNode;
}
}H. Función de carga
Uso flexible de funciones de archivo. En este código, fgetc se usa para obtener datos de archivos uno por uno, lo cual es conveniente para juzgar \n y otro contenido. Cabe señalar que la última línea no puede presionar la tecla Intro.
void List_fLuRu(struct Student* head) //装入函数
{
FILE* fp; //文件指针
int n=0; //数组的位置
int state=0;//链表的位置
char ch; //录入字符
struct Student* List;//链表指针
struct Student* Temp;
List=(struct Student*)malloc(150);
head->pNextNode=List;
if((fp=fopen("C:\\Users\\池上桜\\Desktop\\学习\\课设\\Project\\data.txt","r+"))==NULL) //打开文件
{
printf("No file!\n");
exit(0);
}
while(!feof(fp))
{
ch=fgetc(fp);
if(ch!='\n')//换行
{
if(ch!=' ') //空格切换一次链表位置
{
if(state==0) //链表在ID位置，以下同理
{
List->ID[n]=ch;
List->ID[n+1]='\0';
}
else if(state==1)
{
List->name[n]=ch;
List->name[n+1]='\0';
}
else if(state==2)
{
List->age[n]=ch;
List->age[n+1]='\0';
}
else if(state==3)
{
List->sex[n]=ch;
List->sex[n+1]='\0';
}
else if(state==4)
{
List->address[n]=ch;
List->address[n+1]='\0';
}
else if(state==5)
{
List->Time[n]=ch;
List->Time[n+1]='\0';
}
else if(state==6)
{
List->number[n]=ch;
List->number[n+1]='\0';
}
else
{
printf("格式有误！");
exit(0);
}
n++;
}
else
{
state=state+1;
n=0;
}
}
else
{
Temp = (struct Student*)malloc(150);
List->pNextNode=Temp;
List=Temp;
List->pNextNode=NULL;
n=0;
state=0;
}
}
fclose(fp);
}I. Función de almacenamiento
Use fputs para almacenar todo el contenido de la lista enlazada en un archivo.Recuerde, agregue '\0' después de cada uno para indicar el final.
void List_fCunChu(struct Student* head)
{
FILE* fp; //文件指针
struct Student* List;//链表指针
List=head->pNextNode;
if((fp=fopen("C:\\Users\\池上桜\\Desktop\\学习\\课设\\Project\\sum.txt","w+"))==NULL) //打开文件
{
printf("No file!\n");
exit(0);
}
while(List->pNextNode!=NULL)
{
fputs(List->ID,fp);
fputc('\0',fp);
fputs(List->name,fp);
fputc('\0',fp);
fputs(List->age,fp);
fputc('\0',fp);
fputs(List->sex,fp);
fputc('\0',fp);
fputs(List->address,fp);
fputc('\0',fp);
fputs(List->Time,fp);
fputc('\0',fp);
fputs(List->number,fp);
fputc('\n',fp);
List=List->pNextNode;
}
fputs(List->ID,fp);
fputc('\0',fp);
fputs(List->name,fp);
fputc('\0',fp);
fputs(List->age,fp);
fputc('\0',fp);
fputs(List->sex,fp);
fputc('\0',fp);
fputs(List->address,fp);
fputc('\0',fp);
fputs(List->Time,fp);
fputc('\0',fp);
fputs(List->number,fp);
fclose(fp);
}
Resumir:
La dificultad es extremadamente baja (si el archivo no está incluido), de hecho, es demasiado simple como configuración del curso.
Este curso está diseñado para consolidar contenido como clasificación, búsqueda, listas enlazadas, estructuras, archivos, etc. Cubre una amplia gama de temas y es rico en contenido. Es un buen ejercicio para principiantes.
Llevar adelante el espíritu del código abierto, comenzando desde el primer año ~