Questao 2 em C

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

#include<stdio.h> 
#include<stdlib.h>
#include<string.h>
#include<conio.h>
typedef struct restaurantes /********criacao da lista de restanrantes*******/
{ 
 char nome[40];
 char endereco[100];
 int codigo;
 struct restaurantes *prox;
 struct restaurantes *ant;
} lista;
void listar(lista *atual)/******************funcao listar*****************/
{
lista *p=atual;
if(p==NULL)/*se a lista estiver vazia imprime um aviso*/
printf("\t\t\t **Lista Vazia !**\n\n");
else
{/*caso a lista nao esteja vazia inicia esse bloco*/
 printf("\t\t\t **IMPRESSAO DA LISTA**\n");
do /*impressao da lista*/
 {
 printf("Nome:%s\n",p->nome);
 printf("Endereco:%s\n",p->endereco);
 printf("Codigo:%d\n\n",p->codigo);
 p=p->prox;
 }while(p!=atual);/*condicao necessaria pra continuar a impressao da lista*/
}
}
lista *inserir(lista*atual)/**************funcao inserir*******************/
{ 
lista *novo=NULL,*p;/*ponteiros a serem usados no decorrer da funcao*/
p=atual;
/*variaveis auxiliares */
int cod;
char temp[100],aux[40];
printf("\t\t\t **Novo Elemento!**\n");/*leitura dos novos elementos*/
printf("\n\n");
printf("Nome: ");
gets(aux);
printf("Endereco: ");
gets(temp);
printf("Codigo: ");
scanf("%d", &cod);
if(p==NULL)/* se a lista estiver vazia*/
{
p = (lista *) malloc(sizeof(lista));/*realiza a alocacao da strutura*/
if(p==NULL)/*caso nao der pra alocar imprime aviso e sai do bloco*/
printf("\t\t**Nao foi possivel realizar esta operacao !**\n\n");
else{ /*caso tenha alocado , comeca a passagem da informacoes pra nova lista */
 strcpy(p->nome,aux);
 strcpy(p->endereco,temp);
 p->codigo = cod;
 /*fazendo a ligacao do elemento com ele mesmo*/ 
 p->prox = p;
 p->ant=p;
 }
}
else/*caso ja exista um elemento na lista*/
{
 novo=(lista*)malloc(sizeof(lista));/*realiza a alocacao da strutura*/
 if(novo==NULL)/*caso nao der pra alocar imprime aviso*/
 printf("\t\t**Nao foi possivel realizar esta operacao !**\n\n");
 else{ /*caso tenha alocado, comeca passagem da informacoes pra lista novo*/
 strcpy(novo->nome,aux);
 strcpy(novo->endereco,temp);
 novo->codigo = cod;
 /*ligando o novo elemento com os que ja existem na lista*/
 novo->prox=p;
 novo->ant=p->ant;
 p->ant=novo;
 novo->ant->prox=novo;
 } 
}
return(p);/*retorna a lista atualizada*/ 
}
void alterar(lista *atual)/***************funcao alterar *******************/
{
int cod;
lista *p=atual;
if(p==NULL)/*testa se lista esta vazia e se positivo imprime um aviso*/
printf("\t\t\t **Lista Vazia !**\n\n");
else
{
 printf("Entre com o codigo do restaurante:\n");
 scanf("%d",&cod);
 fflush(stdin);/*limpeza do buffer */
 
 while((p!=atual->ant)&&(p->codigo!=cod))/*condicao de procura*/
 p=p->prox;
 
 if(p->codigo!=cod)/*se nao encontrar o codigo na lista imprime um aviso*/
 printf("\t\t\t **Codigo nao encontrado!!**\n\n");
 else
 {/*se encontrar igual realiza a alteracao*/
 printf("\t\t\t **Iniciar Alteracao!**\n");
 printf("Nome: ");
 gets(p->nome);
 printf("Endereco: ");
 gets(p->endereco);
 printf("\n\n");
 }
}
}
lista *remover(lista *atual)/**************funcao remover******************/
{
lista *p=atual;
int cod;
if(p==NULL)/*testa se a lista esta vazia e imprime um aviso*/
printf("\t\t\t **Lista Vazia !**\n\n");
else
{/*inicia a busca caso a lista nao esteja vazia*/
 printf("Entre com o codigo que deseja remover:\n");
 scanf("%d",&cod);
 while((p!=atual->ant)&&(p->codigo!=cod))/*condicao de procura*/
 p=p->prox;
 
 
 if(p->codigo!=cod)/*se nao encontrar imprime um aviso*/
 printf("\t\t\t **Codigo nao encontrado!!**\n\n");
 else{/*caso encontre inicia a remocao*/
 printf("\t\t\t **Posicao Removida!**\n\n");
 if(p->ant==p)/*verifica se existe apenas um elemento */
 atual=NULL;
 
 else
 {/*se existir mais de um elemento */
 /*faz o anterior apontar pro proximo e vice=versa*/
 p->prox->ant=p->ant;
 p->ant->prox=p->prox;
 if(p==atual) /*caso seja atual a ser removido, faz atual apontar para o 
 proximo */
 atual=p->prox;
 }
 free(p); /*exclui o elemento*/
 } 
}
return(atual);/*retona lista atualizada*/
}
lista* crescente(lista *atual)/***************fucao crescente*****************/
{
lista *p,*temp;/*ponteiros a serem usados no decorrer da funcao*/
if(atual==NULL)/*testa se a lista esta vazia e imprime um aviso caso positivo*/
printf("\t\t\t **Lista Vazia !**\n\n");
else
{/*se existir elementos inicia a operacao*/
 printf("\t\t\t **Operacao Realizada !**\n\n");
 p=atual;
 
 for(p=atual;p!=atual->ant;p=p->prox)/*percorre a lista do 1º ao ultimo*/
 {for(temp=p->prox;temp!=atual;temp=temp->prox)/*percorre atual ate o 1º*/
 if((p->codigo)>(temp->codigo))/*caso a posicao de p tenha codigo maior do que 
 a de temp*/
 {/*retira temp dessa posicao e temp vai pro inicio */
 temp->ant->prox=temp->prox;
 temp->prox->ant=temp->ant;
 /*temp vai ser o 1º da lista*/
 atual->ant->prox=temp;
 temp->ant=atual->ant;
 atual->ant=temp;
 temp->prox=atual;
 atual=temp;/*o 1º elemento agora e o elemento que temp esta apontando*/
 /*p e temp volta para suas posicoes iniciais*/
 p=atual;
 temp=atual;
 }
 }
listar(atual);/* imprime a lista em ordem crescente*/
} 
return(atual); /*retorna a lista*/
} 
lista* decrescente(lista *atual)/************fucao decrescente***************/
{
lista *p,*temp;/*ponteiros a serem usados no decorrer da funcao*/
if(atual==NULL)/*testa se a lista esta vazia e imprime um aviso caso positivo*/
printf("\t\t\t **Lista Vazia !**\n\n");
else
{/*se existir elementos inicia a operacao*/
 printf("\t\t\t **Operacao Realizada !**\n\n");
 p=atual;
 for(p=atual;p!=atual->ant;p=p->prox)/*percorre a lista do 1º ao ultimo*/
 {for(temp=p->prox;temp!=atual;temp=temp->prox)/*percorre a lista do 2° ao 1º*/
 if((p->codigo)<(temp->codigo))/*caso a posicao de p tenha codigo menor do que 
 a de temp*/
 {/*retira temp dessa posicao e temp vai pro inicio */
 temp->ant->prox=temp->prox;
 temp->prox->ant=temp->ant;
 /*temp agora e o 1º*/
 atual->ant->prox=temp;
 temp->ant=atual->ant;
 atual->ant=temp;
 temp->prox=atual;
 atual=temp;/*o 1º elemento agora e o elemento que temp esta apontando*/
 /*p e temp volta para suas posicoes iniciais*/
 p=atual;
 temp=atual;
 }
 }
listar(atual); /*imprime a lista em ordem crescente*/
} 
return(atual); /*retorna a lista*/
} 
/*****************************************************************************/
/************************* continuacao da lista *************************/
void ver_ordem(lista *atual)/*funcao que verifica a ordem da lista*/
{
lista *p=atual,*temp,*aux=NULL;/*ponteiros a serem usados na funcao*/
if(atual==NULL)/*verifica se a lista esta vazia e imprime um aviso caso vazia*/
printf("\t\t\t **Lista Vazia !**\n\n");
else/*se existir elementos na lista inicia operacao*/
{
 if(atual->prox==atual)/*verifica se a lista possui so um elemento e imprime aviso*/ 
 printf("\t\t **A lista possui apenas um elemento!!**\n\n");
 else
 { /*caso tenha mais de um elemento*/ 
 
 for(p=atual;p!=atual->ant;p=p->prox)/*percorre a lista do 1º ao ultimo*/
 { for(temp=p->prox;temp!=atual;temp=temp->prox)/*percorre a lista do 2º ao 1º*/ 
 if((p->codigo)>(temp->codigo))/*verifica se o codigo do elemento que p aponta 
 é mair do o de temp e caso positivo aux aponta pra mesma posicao de p*/
 aux=p;
 }
 if(aux==NULL)/*verifica pra onde aux aponta, se for NULL e porque a lista e
 crescente*/
 printf("\t\t **A lista esta em ordem crescente !**\n\n");
 else/*caso nao seja crescente*/
 { aux=NULL;
 for(p=atual;p!=atual->ant;p=p->prox)/*percorre a lista do 1º
ao ultimo*/
 { for(temp=p->prox;temp!=atual;temp=temp->prox)/*percorre a lista do 2º ao 1º*/ 
 if((p->codigo)<(temp->codigo))/*verifica se o codigo do elemento que p aponta 
 é menor do o de temp e caso positivo aux aponta pra mesma posicao de p*/
 aux=p;
 }
 if(aux==NULL)/*verifica pra onde aux aponta, se for NULL e porque a lista 
 e decrescente*/
 printf("\t\t **A lista esta em ordem decrescente !**\n\n");
 else/*caso nao seja decrescente , alista esta desordenada*/
 printf("\t\t\t**A lista esta desordenada !**\n\n");
 } 
}
}
}
lista *copiar(lista *copia,lista *atual)/*********funcao copiar************/
{
 lista *novo=NULL,*pri=NULL,*p,*anterior,*fim;/*ponteiros a serem usados*/
if(atual!=NULL)/*verifica se alista possui elementos e inicia a operacao caso
 positivo*/
{ 
 printf("\t\t\t**Criando uma copia da lista !**\n\n"); 
 p=atual; 
do 
{ /*aloca espaco do tipo lista*/
 novo=(lista*)malloc(sizeof(lista));
 if(novo==NULL)/*testa se conseguiu alocar imprime aviso caso ocorra erro*/
 printf("\t\t **Nao foi possivel completar esta operacao !**\n\n");
 else
 {/*caso tenha alocado inicia a copia de atual pra copia*/
 strcpy(novo->nome,p->nome);
 strcpy(novo->endereco,p->endereco); 
 novo->codigo=p->codigo;
 /*faz a 1ª copia apontar pra ela mesma*/
 novo->prox=novo;
 novo->ant=novo;
 
 if(pri==NULL)/*testa se ainda nao foi copia nenhum elemento da lista atual*/
 {
 pri=novo;/*se ainda nao existir elementos na copia, pri aponta pra novo*/
 p=p->prox;/*avanca pra outro elemento da lista atual*/
 }
 else/*caso ja exista elementos */ 
 {/*inseri novo elemento na lista copia ja existente*/
 pri->ant->prox=novo;
 novo->ant=pri->ant;
 novo->prox=pri;
 pri->ant=novo;
 p=p->prox;/*avanca pra outro elemento da lista atual*/
 }
 
 }
 
}while(p!=atual);/*condicao de execucao dessa operacao(enquanto p nao 
apontar pro inicio da lista atual)*/
 
if((pri->ant==atual->ant)&&(copia!=NULL))/*caso tenha feito a copia de todos 
os elementos,limpa a lista copia, caso ela ja tivesse elementos antes*/
{
 fim=copia;
 do
 {
 anterior=fim;/*anterior aponta pro elemento a ser excluido*/
 fim=fim->prox;
 free(anterior);
 }while(fim!=copia->ant);/*condicao de execucao, fim nao apntar pro 1º 
elemento de copia*/
 
free(fim);/*exclui elemento*/
}
copia=pri;/*copia recebe a copia da lista atual*/
} 
return (copia); /*retorna copia*/ 
} 
 
lista *exclui_repetbusca(lista *atual)/*funcao que exclui todos os elementos
 dado pelo usuario*/
{
lista *p=atual,*aux;/*ponteiros a serem usados durante a funcao*/ 
int cod;
if(atual!=NULL)/*executa a sequencia abaixo se alista nao estiver vazia*/
{
printf("Entre com o codigo do restaurante:\n");/*solicitacao pro usuario*/
scanf("%d",&cod);/*armazenar variavel o valor digitado pelo usuario*/
 for(p=atual->prox;p!=atual;p=p->prox)/*percorre a lista do 2º ao 1º*/
 if(p->codigo==cod)/*testa se o codigo do elemento que p aponta e igual a cod*/
 {/*exclui o elemento repetido*/
 p->ant->prox=p->prox;
 p->prox->ant=p->ant;
 free(p);
 p=atual;/*p agora aponta pro inicio da lista*/
 
 }
 if(p->codigo==cod)/*testa o elemento que ainda nao tinha sido testado*/
 {
 if(p->prox==p)/*verifica se so existe um elemento*/
 {
 free(p);/*excluir elemento se for unico*/
 p=NULL;
 }
 else/*caso tenha mais elementos*/
 {/*retirada do elemento que p aponta*/
 p->ant->prox=p->prox;
 p->prox->ant=p->ant;
 atual=atual->prox;
 
 free(p);
 p=atual;/*p agora aponta pro inicio da lista*/
 }
 }
}
crescente(p);/*ordena em ordem crescente os elementos que sobrarem 
e retorna os mesmos*/
}
 
lista *inverte(lista *atual)/*******************funcao inverte ****************/
{
 lista *p=atual,*temp;/*ponteiros a serem usados na funcao*/
if(atual==NULL)/*verifica se a lista esta vazia e imprime um aviso caso positivo*/
printf("\t\t\t **Lista Vazia !**\n\n");
else/*caso tenha elementos na lista*/
{
 printf("\t\t\t **Invertendo a Lista !**\n\n");
 do 
 { /*inicia o processo de inversao*/
 temp=p;
 p=p->prox;
 temp->prox=temp->ant;
 temp->ant=p;
 
 }while(p!=atual);/*enquanto p nao chega no inicio da lista*/ 
 atual=temp; 
 
listar(atual);/*impressao da lista*/
} 
return(atual); /*retorno da lista*/
}
lista *copiaeinverte(lista *copia,lista *atual)/*funcao que cria uma copia e a inverte */
{ 
if(atual!=NULL)/*testa se a lista nao esta vazia*/
{
copia=copiar(copia,atual);/*chama a funcao copiar*/
copia=inverte(copia);/*chama a funcao inverte*/
return(copia);
}
else/*caso a lista esteja vazia*/
printf("\t\t\t **Lista Vazia !**\n\n");
} 
lista *excluirepet_copia(lista *copia,lista *atual)/*funcao exclui repeticao e cria copia*/
{
lista *p=NULL,*aux,*temp;/*ponteiros do tipo lista usados na funcao*/
if(atual!=NULL)/*testa se a lista nao esta vazia*/
{
copia=copiar(copia,atual);/*chama funcao copiar*/
for(p=copia;p!=copia->ant;p=p->prox)/*percorre lista copia do 1º ao ultimo elemento*/
 {for(temp=p->prox;temp!=copia;temp=temp->prox)/*percorre copia do 2º ao 1º elemento*/
 
 if(temp->codigo==p->codigo)/*verifica se o codigo do elemento que temp aponta
 é igual ao de p*/
 {/*inicia a exclusao caso ocorra codigo repetido*/
 temp->prox->ant=temp->ant;
 temp->ant->prox=temp->prox;
 free(temp);
 p=copia; 
 temp=p;
 }
 }
 
listar(copia);/*imprime a lista copia*/
}
else/*caso a lista atual esteja vazia*/
printf("\t\t\t **Lista Vazia !**\n\n");
return (copia);/*retorna a lista copia*/
}
lista *intercalar(lista *intercalada,lista *copia,lista *atual)/*funcao intercalar */
{
lista *p,*temp,*aux1,*w,*aux2,*ajuda1,*ajuda2;/*ponteiro do tipo lista que serao 
usados*/
if((copia!=NULL)&&(atual!=NULL))/*verifica se as duas listas estao vazia ou nao*/
{/*caso a lista nao esteja vazia*/
intercalada=copiar(intercalada,atual);/*cria uma copia de atual em intercalada*/
p=intercalada;/*p aponta para o 1º elemento da lista de intercalada*/
w=copiar(w,copia);/*cria um copia da lista copia em w*/
temp=w;/*temp aponta para o 1ºelemento da lista de w*/
ajuda1=intercalada->ant;/*o ponterio ajuda1 aponta para o ultimo elemento
 da lista intercalada*/ 
ajuda2=w->ant;/*o ponteiro ajuda2 aponta pro ultimo elemento da lista w*/
do{/*processo de intercalar*/
 
 if((p==ajuda1)&&(temp==ajuda2))/*verifica se so tem um elemento em cada 
 lista ou se ja terminou ambas as listas----- caso elas tenham mesmo
 tamanho !!*/
 { /*insere o elemento de temp entre os elementos de p*/ 
 ajuda1->prox->ant=ajuda2;
 ajuda2->prox=ajuda1->prox;
 ajuda1->prox=ajuda2;
 ajuda2->ant=ajuda1;
 
 }
 else
 {
 if((p==ajuda1)&&(temp!=ajuda2))/*caso lista p seja menor do que
 lista temp*/ 
 {/*insere o restante dos elementos de temp no final de p*/ 
 ajuda1->prox->ant=ajuda2;
 ajuda2->prox=ajuda1->prox;
 ajuda1->prox=temp;
 temp->ant=ajuda1;
 }
 else
 {
 if((p!=ajuda1)&&(temp==ajuda2))/*caso lista temp seja menor do que p*/
 { 
 /*insere o ultimo elemento de temp e sai*/ 
 p->prox->ant=ajuda2;
 ajuda2->prox=p->prox;
 p->prox=ajuda2;
 ajuda2->ant=p;
 
 p=ajuda1;/*pra finalizar todo o programa*/
 }
 else
 {
 if((p!=ajuda1)&&(temp!=ajuda2)) /*caso as duas listas nao tenham 
 chegado no fim*/
 { 
 aux1=p->prox;/*aux1 guarda o proximo elemento da lista p*/
 aux2=temp->prox;/*aux2 guarda o proximo elemento da lista temp*/
 
 /*coloca o elemento de temp entre os elementos de p*/
 p->prox->ant=temp;
p->prox=temp;
 temp->ant=p;
 temp->prox=aux1;
 
 /*p e temp avancao para o proximo elemento das respectivas listas*/ 
 p=aux1;
 temp=aux2;
 
 if(p==ajuda1)/*caso o proximo elementos seja o ultimo da lista p*/
 
 { /*liga o ultimo elemento de p com os demais de temp*/ 
 ajuda1->prox->ant=ajuda2;
 ajuda2->prox=ajuda1->prox;
 ajuda1->prox=temp;
 temp->ant=ajuda1;
 
 }
 }
 } 
 } 
 } 
 
 }while(p!=ajuda1);/*condicao de necessaria para realizar todos
 os comandos abaixo*/
 
intercalada=crescente(intercalada);/*organiza e imprime tota lista
 intercalada*/ 
 /* retorna lista totalmente intercalada*/
} 
else/*casos copia e/ou atual estejam vazias*/
printf("\t\t **Uma das listas ou as duas esta(o) vazia !!**\n\n"); 
return(intercalada);/*retorna a lista intercalada*/
}
lista *desaloca(lista *alocada)/*f************uncao desaloca*****************/
{
lista *p;
if(alocada!=NULL)/*testa se a lista esta vazia*/
{
 for(p=alocada->prox;p!=alocada;p=p->prox)/*percorre a lista do 2º ate o 1º*/ 
 {/*inicia o processo de desalocacao*/
 p->ant->prox=p->prox;
 p->prox->ant=p->ant;
 free(p);
 p=alocada->prox;
 }
free(p);/*deloca o ultimo elemento que sobrou na lista*/
p=NULL;
alocada=p;
}
return alocada;/*retorna a lista vazia*/
}
/*************************************************************************/
main()/*******execucao do programa*************/
{
 system("color 0A"); 
 /*ponteiros do tipo lista que serao usados nas funcoes*/
lista *atual=NULL;
lista *copia=NULL;
lista *intercalada=NULL;
char opcao;/*variavel usada para armazenar a opcao do usuario*/
do{/*inicio o programa e imprime o menu de opcoes*/
printf(" ______________________* LISTA DE RESTAURANTES *______________\
_________\n"); 
printf("\n\n *MENU*\n\n");
printf("L:Listar \nI:Inserir \nA:Alterar \nE:Excluir \nT:Inverter\
\nV:Verificar ordem\nK:Criar uma copia \nP:Elimina elemento\
 \nY:Inverte e cria uma copia\nC:Ordenar codigo crescente\
 \nD:Ordenar codigo decrescente\nR:Criar uma copia e excluir elementos repetidos\
\nS:Sair\n\n"); 
opcao=getch();/*ler opcao do usuario*/
system("cls");
switch(opcao)
 {/*menu de funcoes e situacoes escolhidas pelo usuario*/
 case 'L': case 'l': listar(atual); break;
 case 'I': case 'i': atual=inserir(atual);break;
 case 'A': case 'a': alterar(atual);break;
 case 'E': case 'e': atual=remover(atual);break;
 case 'C': case 'c': atual=crescente(atual);break; 
 case 'D': case 'd': atual=decrescente(atual);break;
 case 'V': case 'v': ver_ordem(atual);break;
 case 'K': case 'k': listar(copia=copiar(copia,atual));break;
 case 'R': case 'r': copia=excluirepet_copia(copia,atual);break;
 case 'Y': case 'y': copia=copiaeinverte(copia,atual);break;
 case 'T': case 't': atual=inverte(atual);break;
 case 'P': case 'p': atual=exclui_repetbusca(atual);break;
 case'w':intercalada=intercalar(intercalada,copia,atual);break;
 case 'S': case 's': break;
 default :printf("\t\t\t **Opcao Invalida !**\n\n");
 printf("\a");
 }
fflush(stdin); 
 }while((opcao!='S')&& (opcao!='s')); /*condicao de saida do programa*/
/*desalocacao das listas usadas*/ 
atual=desaloca(atual);copia=desaloca(copia);intercalada=desaloca(intercalada); 
}