Estrutura de Dados Complexo

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

#include <stdio.h>
#include <stdlib.h>
/*******************************************************************************************/
/*** SEGUNDO TRABALHO DE ESTRUTURA DE DADOS ***/
/*** EVANDRO MORAES ***/
/*** O TRABALHO TEM COMO INTUITO SIMULAR UM BANCO DE DADOS NA LINGUAGEM C ***/
/*** PARA ISSO FORAM UTILIZADOS COMO RECURSO BASE, TODAS AS AULAS DISPONIBILIZADAS ***/
/*******************************************************************************************/
/************************************************************************************************************************/
/*** lISTA DINAMICA ***/
/************************************************************************************************************************/
struct LD
{
 char nome[50];
 int telefone;
 int cpf;
 char email[50];
};
/************************************************************************************************************************/
/*** LISTA DUPLAMENTE LIGADA ***/
/************************************************************************************************************************/
struct LL_no
{
 struct LL_no *LL_anterior;
 char * LL_dado[50];
 int LL_registro;
 struct LL_no *LL_proximo;
};
/************************************************************************************************************************/
/*** ARVORE BINARIA ***/
/************************************************************************************************************************/
struct AR_no
{
 struct AR_no *esquerda;
 char * AR_dado[50];
 int AR_registro;
 struct AR_no *direita;
};
/********************************************************************************************************************************/
/********************************************************************************************************************************/
/********************************************* FUNCOES DA LISTA DINAMICA *********************************************/
void LD_adicionar(struct LD LD_valor);
void LD_excluir(int LD_registro);
void LD_expandir();
void LD_inicializar();
void LD_finalizar();
void menu();
/********************************************* VARIAVEIS DA LISTA DINAMICA *********************************************/
int LD_tamanho = 2;
int LD_posicao = 0;
struct LD *LD_lista;
int LD_opcao;
struct LD LD_dado;
/********************************************************************************************************************************/
/********************************************************************************************************************************/
/********************************************* FUNCOES DA LISTA DUPLAMENTE LIGADA *********************************************/
struct LL_no *LL_inicio;
struct LL_no *LL_novo;
struct LL_no *LL_aux;
struct LL_no *LL_anterior;
void LL_inicializar();
void LL_finalizar();
void LL_finalizar_elemento(struct LL_no *elemento);
void LL_adicionar_no(char * LL_dado[50],int LL_registro);
void LL_adicionar_no_final();
void LL_adicionar_no_inicio();
void LL_adicionar_no_meio();
void LL_excluir_no(char * LL_dado[50]);
void LL_excluir_no_inicio();
void LL_excluir_no_final();
void LL_excluir_no_meio();
void LL_listar();
void LL_listar_invertido();
struct LL_no *LL_novo_no(char * LL_dado[50], int LL_registro);
void LL_menu();
/********************************************* VARIAVEIS DA LISTA DUPLAMENTE LIGADA *********************************************/
int LL_opcao = 0;
char * nome[50];
int LL_registro;
/********************************************************************************************************************************/
/********************************************************************************************************************************/
/********************************************* FUNCOES DA ARVORE BINARIA *********************************************/
void AR_adicionar(struct AR_no *posicao, struct AR_no *novo);
struct AR_no *AR_novo_no(char *AR_dado[50],int AR_registro);
void AR_inicializar();
void AR_finalizar(struct AR_no *posicao);
struct AR_no *localizar(struct AR_no *posicao, char * AR_dado[50]);
void AR_excluir(char * AR_dado[50]);
void AR_menu();
/********************************************* VARIAVEIS DA ARVORE BINARIA *********************************************/
char ultimo_movimento = ' ';
struct AR_no *AR_inicio;
struct AR_no *AR_anterior;
struct AR_no *AR_aux;
int AR_opcao;
int AR_numero;
int AR_registro;
char AR_nome[50];
/********************************************************************************************************************************/
/********************************************************************/
/*** MAIN ***/
/********************************************************************/
void menu();
int M_registro=0;
int M_opcao;
int M_decision;
int main()
{
 LD_inicializar();
 LL_inicializar();
 AR_inicializar();
 M_opcao = 0;
 while(M_opcao !=6)
 {
 menu();
 switch(M_opcao)
 {
 case 1:
 fflush(stdin);
 printf("\n\nDigite o CPF:");
 scanf("%d",&LD_dado.cpf);
 printf("\n");
 fflush(stdin);
 printf("Digite o nome:");
 gets(LD_dado.nome);
 printf("\n");
 fflush(stdin);
 printf("Digite o email:");
 gets(LD_dado.email);
 printf("\n");
 fflush(stdin);
 printf("Digite o telefone:");
 scanf("%d",&LD_dado.telefone);
 printf("\n");
 M_decision=1;
 LD_adicionar(LD_dado);
 if(M_decision==1)
 {
 LL_adicionar_no(LD_dado.nome,M_registro);
 printf("\n\n*** Arvore Binaria ***\n\n");
 AR_adicionar(AR_inicio,AR_novo_no(LD_dado.nome,M_registro));
 printf("\n**********************\n\n");
 }
 break;
 case 2:
 fflush(stdin);
 printf("\nDigite o nome a qual deseja excluir: ");
 gets(AR_nome);
 AR_aux = localizar(AR_inicio, AR_nome);
 if(AR_aux == 0)
 printf("O nome nao se encontra no banco!\n");
 else
 {
 M_registro=AR_aux->AR_registro;
 AR_excluir(AR_nome);
 LL_excluir_no(AR_nome);
 LD_excluir(M_registro);
 }
 break;
 case 3:
 fflush(stdin);
 printf("\nDigite o nome da pessoa que deseja alterar: ");
 gets(AR_nome);
 AR_aux = localizar(AR_inicio, AR_nome);
 if(AR_aux == 0)
 printf("O nome nao se encontra no sistema!\n");
 else
 {
 M_registro=AR_aux->AR_registro;
 int opcao=0;
 while(opcao!=3)
 {
 printf("\n\n****************************\n");
 printf("\n Nome: %s \n",AR_nome);
 printf(" Email: %s ",LD_lista[M_registro].email);
 printf("\n Telefone: %d ",LD_lista[M_registro].telefone);
 printf("\n\n Entre com o numero do opcao desejada:");
printf("\n 1- Alterar Email ");
 printf("\n 2- Alterar Telefone ");
 printf("\n 3- Sair\n\n");
 printf("Opcao: ");
 scanf("%d",&opcao);
 switch(opcao)
 {
 case 1:
 fflush(stdin);
 printf("\nDigite o novo email:");
 gets(LD_lista[M_registro].email);
 printf("\nAlterado com sucesso!\n");
 break;
 case 2:
 fflush(stdin);
 printf("\nDigite o novo telefone:");
 scanf("%d",&LD_lista[M_registro].telefone);
 printf("\nAlterado com sucesso!\n");
 break;
 }
 printf("\n\n****************************\n");
 }
 }
 break;
 case 4:
 FF_listar();
 break;
 case 5:
 LL_listar_invertido();
 break;
 }
 }
 printf("\n\n*** Finalizando o programa..... ***\n\n");
 AR_finalizar(AR_inicio);
 LL_finalizar();
 LD_finalizar();
 printf("\n\n***********************************\n\n");
}
/************************************************************************************************************************/
/*** FUNCOES ***/
/************************************************************************************************************************/
/************************************************************************/
/*** FAZ A IMPRESSAO DO MENU DE SELECOES ***/
/************************************************************************/
void menu()
{
 printf("\n\nSimulador de Banco de Dados em Linguagem C\n\n");
 printf("1) Cadastrar\n");
 printf("2) Excluir\n");
 printf("3) Editar\n");
 printf("4) Listar de forma crescente\n");
 printf("5) Listar de forma decrescente\n");
 printf("6) Sair\n");
 printf("Entre com a opcao desejada: ");
 scanf("%d", &M_opcao);
}
/************************************************************************************************************************/
/*** LISTA DINAMICA ***/
/************************************************************************************************************************/
void LD_excluir(int LD_registro)
{
 strcpy(LD_lista[LD_registro].nome,"*");
 printf("\n\n*** Lista Dinamica ***\n");
 printf("\n Excluido com sucesso! \n");
 printf(" O nome foi alterado para: %s \n",LD_lista[LD_registro].nome);
 printf("\n***********************************\n\n");
}
void LD_inicializar()
{
 LD_lista = malloc(LD_tamanho * sizeof(struct LD));
 if(!LD_lista)
 {
 printf("Erro de alocacao!");
 exit(-1);
 }
}
void LD_finalizar()
{
 free(LD_lista);
}
void LD_expandir()
{
 printf("\nExpandindo lista duplamente ligada...\n\n");
 int novoTamanho = LD_tamanho + (LD_tamanho);
 struct LD *p;
 int i;
 p = malloc(novoTamanho * sizeof(struct LD));
 if(!p)
 {
 printf("Erro na alocacao de memoria!");
 exit(-1);
 }
 for(i = 0; i < LD_tamanho; i++)
 {
 strcpy(p[i].nome,LD_lista[i].nome );
 p[i].telefone=LD_lista[i].telefone;
 strcpy(p[i].email,LD_lista[i].email );
 }
 free(LD_lista);
 LD_lista = p;
 LD_tamanho = novoTamanho;
}
void LD_adicionar(struct LD LD_valor)
{
 if(LD_posicao < LD_tamanho)
 {
 AR_aux = localizar(AR_inicio, LD_valor.nome);
 if(AR_aux == 0)
 {
 LD_lista[LD_posicao]=LD_valor;
 M_registro=LD_posicao;
 LD_posicao++;
 }
 else
 {
 printf("ATENCAO! O nome ja se encontra no sistema\n\n");
 M_decision=0;
 return 0;
 }
 }
 else
 {
 LD_expandir();
 LD_adicionar(LD_valor);
 }
 if(M_decision==1)
 {
 printf("\n*** Lista Dinamica ***\n");
 printf("\n Adicionado com Sucesso! \n");
 printf("\n CPF: %d",LD_lista[LD_posicao-1].cpf);
 printf("\n Nome: %s",LD_lista[LD_posicao-1].nome);
 printf("\n Telefone:%d",LD_lista[LD_posicao-1].telefone);
 printf("\n Email:%s \n",LD_lista[LD_posicao-1].email);
 printf("\n********************\n");
 }
}
/************************************************************************************************************************/
/*** LISTA DUPLAMENTE LIGADA ***/
/************************************************************************************************************************/
void LL_inicializar()
{
 LL_inicio = 0;
}
struct LL_no *LL_novo_no(char * LL_dado[50],int LL_registro)
{
 struct LL_no *n;
 n = malloc(sizeof(struct LL_no));
 if(!n)
 {
 printf("Nao foi possivel alocar memoria!\n");
 exit(-1);
 }
 n->LL_anterior = 0;
 strcpy(n->LL_dado,LL_dado);
 n->LL_proximo = 0;
 n->LL_registro=LL_registro;
 return n;
}
void LL_adicionar_no(char * LL_dado[50], int LL_registro)
{
 LL_novo = LL_novo_no(LL_dado,LL_registro);
 if(LL_inicio == 0)
 {
 LL_inicio = LL_novo;
 printf("\n\n*** Lista Duplamente Ligada ***\n");
 printf("\n Adicionou no Inicio! \n");
 printf("\n*******************************\n");
 }
 else
 {
 // vai decidir onde inserir
 if(strcmp(LL_inicio->LL_dado,LL_dado)>=0)
 LL_adicionar_no_inicio();
 else
 {
 LL_aux = LL_inicio;
 while(LL_aux->LL_proximo != 0 && strcmp(LL_aux->LL_dado,LL_dado)<=0)
 {
 LL_aux = LL_aux->LL_proximo;
 }
 if(LL_aux->LL_proximo == 0 && strcmp(LL_dado,LL_aux->LL_dado)>0 )
 LL_adicionar_no_final();
 else
 LL_adicionar_no_meio();
 }
 }
}
void LL_adicionar_no_final()
{
 LL_aux->LL_proximo = LL_novo;
 LL_novo->LL_anterior = LL_aux;
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Adicionou ao final da lista \n");
 printf("\n*******************************\n");
}
void LL_adicionar_no_inicio()
{
 LL_novo->LL_proximo = LL_inicio;
 LL_inicio->LL_anterior = LL_novo;
 LL_inicio = LL_novo;
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Adicionou no Inicio \n");
 printf("\n*******************************\n");
}
void LL_adicionar_no_meio()
{
 LL_anterior = LL_aux->LL_anterior;
 LL_novo->LL_proximo = LL_aux;
 LL_anterior->LL_proximo = LL_novo;
 LL_aux->LL_anterior = LL_novo;
 LL_novo->LL_anterior = LL_anterior;
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Foi adicionado no meio \n");
 printf("\n********************************\n");
}
void LL_excluir_no(char * LL_dado[50])
{
 if(LL_inicio == 0)
 {
 printf("Impossivel excluir! A ista ja esta vazia!\n");
 }
 else
 {
 if(strcmp(LL_inicio->LL_dado,LL_dado)==0)
 FF_excluir_no_inicio();
 else
 {
 LL_aux = LL_inicio;
 while(LL_aux->LL_proximo != 0 &&strcmp(LL_aux->LL_dado,LL_dado)!=0)
 {
 LL_aux = LL_aux->LL_proximo;
}
 if(strcmp(LL_aux->LL_dado,LL_dado)==0)
 if(LL_aux->LL_proximo == 0)
 FF_excluir_no_final();
 else
 FF_excluir_no_meio();
 else
 printf("Impossivel excluir! Nao encontrei o elemento.\n");
 }
 }
}
void FF_excluir_no_final()
{
 LL_anterior = LL_aux->LL_anterior;
 LL_anterior->LL_proximo = 0;
 free(LL_aux);
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Excluido com sucesso no final \n");
 printf("\n*******************************\n");
}
void FF_excluir_no_inicio()
{
 LL_aux = LL_inicio;
 if(LL_inicio->LL_proximo != 0)
 {
 LL_inicio = LL_inicio->LL_proximo;
 LL_inicio->LL_anterior = 0;
 free(LL_aux);
 }
 else
 {
 free(LL_aux);
 LL_inicio = 0;
 }
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Excluido com sucesso no inicio! \n");
 printf("\n********************************\n");
}
void FF_excluir_no_meio()
{
 struct LL_no *LL_proximo;
 LL_anterior = LL_aux->LL_anterior;
 LL_proximo = LL_aux->LL_proximo;
 LL_anterior->LL_proximo = LL_proximo;
 LL_proximo->LL_anterior = LL_anterior;
 free(LL_aux);
 printf("\n*** Lista Duplamente Ligada ***\n");
 printf("\n Excluido com sucesso no meio \n");
 printf("\n*******************************\n");
}
void LL_finalizar()
{
 if(LL_inicio != 0)
 {
 LL_finalizar_elemento(LL_inicio);
 LL_inicio = 0;
 }
}
void LL_finalizar_elemento(struct LL_no *elemento)
{
 if(elemento->LL_proximo != 0)
 LL_finalizar_elemento(elemento->LL_proximo);
 free(elemento);
}
void FF_listar()
{
 if(LL_inicio != 0)
 {
 printf("\n********************************\n");
 LL_aux = LL_inicio;
 while(LL_aux->LL_proximo != 0)
 {
 printf("\nCPF: %d",LD_lista[LL_aux->LL_registro].cpf);
 printf("\nNome: %s",LL_aux->LL_dado);
 printf("\nEmail: %s",LD_lista[LL_aux->LL_registro].email);
 printf("\nTelefone: %d\n",LD_lista[LL_aux->LL_registro].telefone);
 LL_aux = LL_aux->LL_proximo;
 }
 printf("\nCPF: %d",LD_lista[LL_aux->LL_registro].cpf);
 printf("\nNome: %s",LL_aux->LL_dado);
 printf("\nEmail: %s",LD_lista[LL_aux->LL_registro].email);
 printf("\nTelefone: %d\n",LD_lista[LL_aux->LL_registro].telefone);
 printf("\n********************************\n");
 }
 else
 printf("Sem dados no sistema!\n");
}
void LL_listar_invertido()
{
 if(LL_inicio != 0)
 {
 printf("\n********************************\n");
 LL_aux = LL_inicio;
 while(LL_aux->LL_proximo != 0)
 {
 LL_aux = LL_aux->LL_proximo;
 }
 while(LL_aux->LL_anterior != 0)
 {
 printf("\nCPF: %d",LD_lista[LL_aux->LL_registro].cpf);
 printf("\nNome: %s",LL_aux->LL_dado);
 printf("\nEmail: %s",LD_lista[LL_aux->LL_registro].email);
 printf("\nTelefone: %d\n",LD_lista[LL_aux->LL_registro].telefone);
 LL_aux = LL_aux->LL_anterior;
 }
 printf("\nCPF: %d",LD_lista[LL_aux->LL_registro].cpf);
 printf("\nNome: %s",LL_aux->LL_dado);
 printf("\nEmail: %s",LD_lista[LL_aux->LL_registro].email);
 printf("\nTelefone: %d\n",LD_lista[LL_aux->LL_registro].telefone);
 printf("\n********************************\n");
 }
 else
 printf("Sem dados no sistema!\n");
}
/************************************************************************************************************************/
/*** ARVORE BINARIA ***/
/************************************************************************************************************************/
void AR_inicializar()
{
 AR_inicio = 0;
}
void AR_adicionar(struct AR_no *posicao, struct AR_no *novo)
{
 if(posicao==0)
 {
 AR_inicio=novo;
 printf("Adicionou no meio o nome %s!\n",novo->AR_dado);
 }
 else
 {
 if( strcmp(novo->AR_dado,posicao->AR_dado)>=0) //adiciona direita
 {
 if(posicao->direita==0)
 {
 printf("Adicionando %s a direita de %s!\n", novo->AR_dado, posicao->AR_dado);
 posicao->direita=novo;
 }
 else
 {
 printf("Indo para a direita de %s!\n", posicao->AR_dado);
 posicao=posicao->direita;
 AR_adicionar(posicao,novo);
 }
 }
 else // adiciona esquerda
 {
 if( strcmp(novo->AR_dado,posicao->AR_dado)<=0)
 {
 if(posicao->esquerda==0)
 {
 printf("Adicionando %s a esquerda de %s!\n", novo->AR_dado, posicao->AR_dado);
 posicao->esquerda=novo;
 }
 else
 {
 printf("Indo para a esquerda de %s!\n", posicao->AR_dado);
 posicao=posicao->esquerda;
 AR_adicionar(posicao,novo);
 }
 }
 }
 }
}
struct AR_no *AR_novo_no(char *AR_dado[50], int AR_registro)
{
 struct AR_no *novo;
 novo = malloc(sizeof(struct AR_no));
 if(!novo)
 {
 printf("Nao foi possivel alocar memoria\n");
 exit(-1);
 }
 novo->esquerda = 0;
 strcpy(novo->AR_dado,AR_dado);
 novo->AR_registro=AR_registro;
 novo->direita = 0;
 return novo;
}
void AR_finalizar(struct AR_no *posicao)
{
 if(posicao!=0)
 {
 printf("Processando esquerda de %s\n", posicao->AR_dado);
 if(posicao->esquerda != 0)
 AR_finalizar(posicao->esquerda);
 printf("Processando direita de %s\n", posicao->AR_dado);
 if(posicao->direita != 0)
 AR_finalizar(posicao->direita);
 printf("Liberando %s\n", posicao->AR_dado);
 free(posicao);
 }
}
struct AR_no *localizar(struct AR_no *posicao, char * AR_dado[50])
{
 if(posicao == 0)
 return 0;
 if(posicao == AR_inicio)
 AR_anterior = AR_inicio;
 if(strcmp(posicao->AR_dado,AR_dado)==0)
 return posicao;
 else
 {
 AR_anterior = posicao;
 if(strcmp(AR_dado,posicao->AR_dado)>0 && posicao->direita != 0)
 {
 ultimo_movimento = 'D';
 return localizar(posicao->direita, AR_dado);
 }
 if(strcmp(AR_dado,posicao->AR_dado)<0 && posicao->esquerda != 0)
 {
 ultimo_movimento = 'E';
 return localizar(posicao->esquerda, AR_dado);
 }
 return 0;
 }
}
void AR_excluir(char * AR_dado[50])
{
 AR_aux = localizar(AR_inicio, AR_dado);
 if(AR_aux == 0)
 printf("Impossivel excluir, registro nao existente\n");
 else
 {
 if(AR_aux == AR_inicio)
 {
 AR_inicio = 0;
 if(AR_aux->esquerda != 0)
 AR_adicionar(AR_inicio, AR_aux->esquerda);
 if(AR_aux->direita != 0)
 AR_adicionar(AR_inicio, AR_aux->direita);
 free(AR_aux);
 }
 else
 {
 if(ultimo_movimento == 'D')
 AR_anterior->direita = 0;
 else
 AR_anterior->esquerda = 0;
 if(AR_aux->esquerda != 0)
 AR_adicionar(AR_inicio, AR_aux->esquerda);
 if(AR_aux->direita != 0)
 AR_adicionar(AR_inicio, AR_aux->direita);
 free(AR_aux);
 }
 printf("\n\n*** Arvore Binaria ***\n");
 printf("\n Excluida com sucesso \n");
 printf("\n************************\n\n");
 }
}