(conteúdo do arquivo agora adicionado)
(versão: 2.0, modificado: sort, store, load)
Exigir:
Em primeiro lugar, uma análise simples do tema: gerenciamento de dados, só precisa de uma simples lista vinculada para ser concluída. Os métodos de gerenciamento incluem entrada (adicionando os dados digitados no teclado ao final da lista vinculada), armazenamento (armazenando os dados do aluno do programa em um arquivo), carregamento (carregando os dados do aluno no arquivo no programa), modificação ( Modificar um item nos dados do aluno), inserir (inserir os dados do aluno na lista vinculada), excluir (excluir os dados do aluno), pesquisar (encontrar os dados do aluno através do número do aluno), classificar (número do aluno de pequeno a classificação grande), show (exibe todos os dados do aluno).
A dificuldade é muito clara: 1. Os dados de arquivos e programas são transferidos entre si. 2. Ordenação de listas encadeadas.
1. Programação modular.
Para facilitar a modificação e compreensão do código, recomendo a programação modular neste projeto de curso.
Esse tipo de programa grande tem pelo menos 500 linhas.Se for colocado em apenas um arquivo, a profundidade será muito profunda e o código será longo e malcheiroso.
Para alcançar a programação modular, aqui falarei sobre a implementação simples da programação modular.
A. Crie o arquivo de cabeçalho
Muitos estudantes universitários ignoram a importância dos arquivos de cabeçalho. Por meio de um arquivo de cabeçalho, podemos usar uma estrutura em dois arquivos c (totalmente refletido no design deste curso). Com o arquivo de cabeçalho, se você precisar usar o código que escreveu até agora, poderá chamá-lo rapidamente por meio do arquivo de cabeçalho. O arquivo de cabeçalho é escrito da seguinte forma:
A mais importante delas é a parte circundada pela caixa vermelha. Este é um conteúdo indispensável de cada arquivo de cabeçalho. O conteúdo após ifndef e define é o nome do arquivo de cabeçalho. O formato é inserido. Observe que há dois sublinhados na frente.
Declare as funções no arquivo c no arquivo de cabeçalho e use a estrutura no arquivo de cabeçalho, o que reduzirá bastante a quantidade de gravação no arquivo c.
B. Referências em arquivos c
O método de referência é o seguinte
Use este formato para fazer referência a arquivos de cabeçalho.
2. Exibição geral do código
O código geral é colocado aqui primeiro e será explicado um a um posteriormente.
código do arquivo 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); //存储
#endifObserve que na última linha do arquivo de cabeçalho, deixe uma linha em branco para evitar alguns erros metafísicos.
3. Análise completa do código
A. O código na função principal main.cpp:
Como a lógica do código em main.cpp é simples, apenas uma coluna é necessária para explicá-la claramente.
Primeiro, crie uma lista encadeada vazia como o nó principal. Este método de criação é o método de criação de lista linear padrão no livro oficial de estrutura de dados, que pode facilitar muitas operações no futuro (como classificação). Em seguida, deixe o próximo item do a lista encadeada aponta para NULL, pois No final do julgamento, esta lista encadeada é onde todos os dados são armazenados.
Em seguida, use scanf para receber a operação que o usuário deseja executar e pergunte continuamente às necessidades do usuário no loop while para atingir o objetivo de gerenciar o sistema. Um segundo scanf precisa ser adicionado a cada while de segundo nível para receber o usuário depois de usar uma intenção de função.
Este é aproximadamente o conteúdo da função principal.
B. O código do arquivo de cabeçalho line_list.h:
line_list.h é um arquivo de cabeçalho simples. O que precisa ser dito aqui é a estrutura interna. Aqui, a estrutura não pode ser renomeada como Aluno, caso contrário, um erro será relatado. Embora eu não saiba por que, basta seguir o procedimento acima a prática do código não será perturbada pela metafísica.
C. O código da biblioteca de funções line_list.cpp:
Analise de cima para baixo
a. Função de entrada
A entrada é para conectar os dados ao próximo bit da lista vinculada atual. Portanto, ele precisa ser inserido como o nó principal e o último nó da lista vinculada atual é encontrado pelo loop while e, em seguida, a lista vinculada é criado, o conteúdo é inserido e a lista encadeada é conectada ao último nó e, em seguida, aponta o próximo bit do último nó para NULL.
NULL é usado para julgar a cauda da lista vinculada, o que, sem dúvida, reflete sua excelente funcionalidade aqui.
código:
b. Função de exibição
Por que colocar a função de exibição em uma posição tão alta? Isso é claro, porque somente com a exibição você pode saber se há algum problema com sua escrita.
A função de exibição começa após o nó principal e exibe os dados em cada tabela até NULL.
c. Modificar função
A modificação requer que o usuário escolha o conteúdo a ser modificado, então a entrada é um número de série e um número de coluna. O número de série refere-se ao número de série dos dados na lista encadeada atual exibida por meio do display, e o número da coluna é o alvo da modificação (por exemplo, o número do aluno é 1)
Também use primeiro while para encontrar os dados que precisam ser modificados e, em seguida, use a instrução if para determinar o número da coluna, que pode ser modificado com precisão.
(papel)
d. Inserir função
Exiba a lista encadeada primeiro e pergunte quanto precisa ser inserido após o número de série. Defina os ponteiros das três listas encadeadas na frente, no meio e atrás na função e conecte os três ponteiros depois de encontrar a posição.
e. Excluir função
A operação de exclusão também requer vários ponteiros. Depois de encontrar a posição, altere o último do ponteiro anterior para o próximo do destino de exclusão, você pode pular diretamente o destino de exclusão e, finalmente, liberar
f. Localizar função
A função de busca é a mais simples logicamente, cabendo apenas julgar se está de acordo com o alvo da busca, por isso não a repetirei aqui.
g. Função de classificação
Na função de classificação, o método de classificação de bolhas é usado. A implementação específica é a seguinte. Nesta função, a vantagem de transformar o ponteiro de cabeça em vazio é refletida. Mais um ponteiro evita se julgar se é um ponteiro de cabeça.
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. Função de carga
Uso flexível de funções de arquivo. Neste código, fgetc é usado para obter dados de arquivos um a um, o que é conveniente para julgar \n e outros conteúdos. Observe que a última linha não pode ser pressionada com a tecla Enter.
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. Função de armazenamento
Use fputs para armazenar todo o conteúdo da lista encadeada em um arquivo. Lembre-se, adicione '\0' após cada um para indicar o fim.
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:
A dificuldade é extremamente baixa (se o arquivo não estiver incluído), é realmente muito simples como configuração do curso.
Este curso foi desenvolvido para consolidar conteúdos como ordenação, busca, listas encadeadas, estruturas, arquivos, etc. Abrange uma ampla gama de tópicos e é rico em conteúdo. É um bom exercício para iniciantes.
Leve adiante o espírito de código aberto, começando pelo calouro~