Olá, pessoal!
No nosso segundo lab de CES-11 tivesmos que implementar um dicionário utilizando hash table (tabela de dispersão). O programa está logo abaixo!
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct palavra palavra;
typedef struct significado significado;
typedef palavra *vetor;
/***********************************************************************
estrutura de um significado de uma dada expressão
***********************************************************************/
struct significado{
char definicao[50];
significado *proximo;
};
/***********************************************************************
estrutura de uma expressao
***********************************************************************/
struct palavra{
char expressao[50];
significado *significados;
palavra *prox;
};
///Funções:
/***********************************************************************
funcao que calcula a posicao de uma expressao no dicionario
***********************************************************************/
int dispersao(char exp[], int N){
int soma=0;
for(int i=0; exp[i]!='\0'; i++)
soma+=exp[i];
soma=soma%N;
return soma;
}
/***********************************************************************
funcao que INSERE uma nova palavra com um novo significado na tabela
de dispersao
***********************************************************************/
void inserir(char exp[], char def[], vetor *dicionario, int n){
int posicao;
posicao=dispersao(exp, n);
palavra *auxiliar, *copia;
significado *aux, *cola;
int palavra_igual=0;
int significado_igual=0;
for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=dicionario[posicao]->prox){
if(strcmp(auxiliar->expressao, exp)==0){
palavra_igual=1;
for(aux=auxiliar->significados; aux!=NULL; aux=aux->proximo){
if(strcmp(aux->definicao, def)==0){
significado_igual=1;
}
}
if(significado_igual==0){
cola=auxiliar->significados;
aux=(significado*)malloc(sizeof(significado));
auxiliar->significados=aux;
aux->proximo=cola;
strcpy(aux->definicao, def);
}
}
}
if(palavra_igual==0){
copia=dicionario[posicao];
auxiliar=(palavra*)malloc(sizeof(palavra));
dicionario[posicao]=auxiliar;
dicionario[posicao]->significados=(significado*)malloc(sizeof(significado));
auxiliar->prox=copia;
strcpy(dicionario[posicao]->significados->definicao, def);
strcpy(dicionario[posicao]->expressao, exp);
dicionario[posicao]->significados->proximo=NULL;
}
}
/***********************************************************************
funcao que CARREGA A BASE DE DADOS inicial do dicionario
***********************************************************************/
void baseDeDados(vetor *dicionario, int n, FILE *inicio){
char linha[100], *pch, exp[50], total[100], def[50];
while(fscanf(inicio, "%s",total)!=EOF){
fgets(linha, 101, inicio);
strcat(total, linha);
total[strlen(total)-1]='\0';
strcpy(linha, total);
pch=strtok(total, "|");
strcpy(exp, pch);
pch=strtok(NULL, "|");
strcpy(def, pch);
inserir(exp, def, dicionario, n);
}
}
/***********************************************************************
funcao que CONSULTA uma expressao no dicionario
***********************************************************************/
void consultar(FILE *saida, char exp[], int n, vetor *dicionario){
int posicao;
palavra *auxiliar;
significado *aux;
posicao=dispersao(exp, n);
int encontrada=0;
for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=auxiliar->prox){
if(strcmp(auxiliar->expressao, exp)==0){
encontrada=1;
for(aux=dicionario[posicao]->significados; aux!=NULL; aux=aux->proximo){
fprintf(saida, "%s\n", aux->definicao);
}
fprintf(saida, "\n");
}
}
if(encontrada==0){
fprintf(saida, "nada consta\n\n");
}
}
/***********************************************************************
funcao que ELIMINA um significado do dicionario
***********************************************************************/
void eliminar_significado(vetor *dicionario, int n, char exp[], char def[]){
int posicao;
posicao=dispersao(exp, n);
palavra *auxiliar;
significado *aux, *copia, *anterior;
anterior=NULL;
for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=auxiliar->prox){
if(strcmp(auxiliar->expressao, exp)==0){
for(aux=dicionario[posicao]->significados; aux!=NULL; anterior=aux, aux=aux->proximo){
if(strcmp(aux->definicao, def)==0){
if(anterior==NULL){
dicionario[posicao]->significados=aux->proximo;
}
else{
copia=aux->proximo;
anterior=copia;
}
free(aux);
}
}
}
}
}
/***********************************************************************
funcao que ELIMINA uma expressao do dicionario
***********************************************************************/
void eliminar_expressao (vetor *dicionario, int n, char exp[]){
int posicao;
posicao=dispersao(exp, n);
palavra *auxiliar, *anterior;
significado *aux, *next;
anterior=NULL;
for(auxiliar=dicionario[posicao]; auxiliar!=NULL; anterior=auxiliar, auxiliar=auxiliar->prox){
if(strcmp(auxiliar->expressao, exp)==0){
aux=auxiliar->significados;
next=aux->proximo;
if(anterior!=NULL){
anterior=auxiliar->prox;
}
else{
dicionario[posicao]=auxiliar->prox;
}
while(aux!=NULL){
free(aux);
aux=aux->proximo;
}
free(auxiliar);
}
}
}
/***********************************************************************
funcao que gera a base de dados final
***********************************************************************/
void gerar_base(int n, vetor *dicionario){
palavra *auxiliar;
significado *aux;
FILE *base;
base=fopen("dicionitaa.txt", "w");
for(int i=0; i<n; i++){
for(auxiliar=dicionario[i]; auxiliar!=NULL; auxiliar=auxiliar->prox){
for(aux=dicionario[i]->significados; aux!=NULL; aux=aux->proximo){
fprintf(base, "%s|%s\n", auxiliar->expressao, aux->definicao);
}
}
}
fprintf(base, "\n");
fclose(base);
}
/*************************************************************************************/
int main(){
int vezes, operacao, n;
char linha[100], lixo, exp[50], def[50], *pch;
vetor *dicionario;
FILE *entrada, *inicio, *saida;
entrada=fopen("entrada.txt", "r");
inicio=fopen("DicionITA.txt", "r");
saida=fopen("saida.txt", "w");
fscanf(entrada, "%d %d", &n, &vezes);
dicionario=(vetor*)malloc(n*sizeof(vetor));
for(int i=0; i<n; i++){
dicionario[i]=NULL;
}
while(vezes>0){
fscanf(entrada, "%d%c", &operacao, &lixo);
fgets(linha, 101, entrada);
linha[strlen(linha)-1]='\0';
switch(operacao){
case 1:
baseDeDados(dicionario, n, inicio);
break;
case 2:
consultar(saida, linha, n, dicionario);
break;
case 3:
pch=strtok(linha, "|");
strcpy(exp, pch);
pch=strtok(NULL, "|");
strcpy(def, pch);
inserir(exp, def, dicionario, n);
break;
case 4:
pch=strtok(linha, "|");
strcpy(exp, pch);
pch=strtok(NULL, "|");
strcpy(def, pch);
eliminar_significado(dicionario, n, exp, def);
break;
case 5:
eliminar_expressao (dicionario, n, linha);
break;
case 6:
gerar_base(n, dicionario);
break;
}
vezes--;
}
fclose(entrada);
fclose(inicio);
fclose(saida);
return 0;
}
Nenhum comentário:
Postar um comentário