int main(void){
int qtd_num;
int tam;
TLista T;
InicializaLista(&T);
//scanf("%d", &tam);
int num;
int i;
tam = 10;
printf("Insira o tamanho total da memória desejada: ");
scanf("%d", &tam);
Insere(&T, tam);
printf("\n");
printf("Insira a quantidade de processos de tamanho aleatório desejada: ");
scanf("%d", &qtd_num);
printf("\n");
//###############################################################
//Gerar fila aleatória
srand(time(NULL));
for(i = 0; i < qtd_num ; i++){
num = 1 + (rand() / tam);
//scanf("%d", &num);
Insere(&T, num);
//Remove(&T, num);
//ImprimeAlocado(&T);
}
ImprimeAlocado(&T);
//###############################################################
//Remoção de nós
Remove(&T, 1);
ImprimeAlocado(&T);
Remove(&T, 2);
ImprimeAlocado(&T);
Remove(&T, 3);
ImprimeAlocado(&T);
//#############################################################333
//Inserção de nós
Insere(&T, 10);
ImprimeAlocado(&T);
return 0;
}
void Insere(Registro x, Apontador *p)
{ if (*p == NULL)
{ *p = (Apontador)malloc(sizeof(No));
(*p)->Reg = x; (*p)->Esq = NULL; (*p)->Dir = NULL;
return;
}
if (x.Chave < (*p)->Reg.Chave)
{ Insere(x, &(*p)->Esq); return; }
if (x.Chave > (*p)->Reg.Chave)
Insere(x, &(*p)->Dir);
else
printf("Erro : Registro ja existe na arvore\n");
}
void filaencadeada(int op)
{
int ele;
switch(op){
case 0:
exit(1);
break;
case 1:
Fvazia();
break;
case 2:
Imprime();
break;
case 3:
printf("Novo Elemento:\n");
scanf("%d",&ele);
Insere(ele);
break;
case 4:
printf("Buscar Elemento:\n");
scanf("%d",&ele);
Pesquisa(ele);
break;
case 5:
Remove();
Imprime();
break;
default:
printf("Comando invalido\n\n");
}
}
int Cores(TipoGrafo Grafo){
int i, cor = 0, coloriu = 0;
int Cores[Grafo.NumVertices];
TipoLista Coloridos;
TipoItem x;
for(i=0;i<Grafo.NumVertices;i++){//PARA CADA VÉRTICE DO GRAFO
Cores[i] = INCOLOR; //INICIALIZA INCOLOR
}
FLVazia(&Coloridos);//FAZ LISTA DE VERTICES A SEREM COLORIDOS
while(coloriu!=Grafo.NumVertices){//ENQUANTO NAO COLORIU TUDO
for(i=0;i<Grafo.NumVertices;i++){//PARA CADA VÉRTICE DO GRAFO
if(Cores[i]==INCOLOR){//SE NÃO ESTIVER COLORIDO
if(!AdjacenteColorido(Grafo.Adj[i], Coloridos)){//SE NÃO TIVER ADJACENTE COLORIDO COM MESMA COR
Cores[i]=cor;//COLORE O VÉRTICE
x.Vertice=i;
Insere(&x, &Coloridos);//INSERE NA LISTA DE COLORIDOS
coloriu++;
}
}
}
cor++;
EsvaziaLista(&Coloridos);
}
return cor;
}
/*-- Entram aqui os operadores do Programa 6.2 --*/
void InsereAresta(TipoValorVertice *V1, TipoValorVertice *V2,
TipoPeso *Peso, TipoGrafo *Grafo)
{ TipoItem x;
x.Vertice = *V2;
x.Peso = *Peso;
Insere(&x, &Grafo->Adj[*V1]);
}
void Insere(Registro x, Apontador *p)
{ if (*p == NULL)
{ *p = (Apontador)malloc(sizeof(No));
(*p)->Reg = x; (*p)->Esq = NULL; (*p)->Dir = NULL;
(*p)->ocorrencia = 1;
return;
}
if (strcmp(x.Chave, (*p)->Reg.Chave)<0)
{ Insere(x, &(*p)->Esq); return; }
if (strcmp(x.Chave, (*p)->Reg.Chave)>0)
Insere(x, &(*p)->Dir);
else {
(*p)->ocorrencia = (*p)->ocorrencia + 1;
printf("Registro %s já existente na árvore.\nAcrescentando mais uma recorrencia desse registro!..\n", x.Chave);
}
}
void le_linha (TipoLista *lista)
{
char *linha = (char*) malloc((MAX+1) * sizeof(char)); // tamanho maximo
char *token;
TipoPalavra pToken;
const char delim[] = " \n"; // delimitadores: espaco (" ") e quebra de linha (\n)
int i = 0; // contador para a Chave de cada palavra
// le a linha da entrada padrao (stdin) e armazena em 'linha'
fgets(linha, MAX, stdin);
// pega o primeiro token
token = strtok(linha, delim);
// percorre enquanto ainda houver tokens
while( token != NULL )
{
i++; // incrementa o contador para as Chaves
// atualiza as demais informacoes do TipoPalavra: Chave e Tamanho (alocado dinamicamente)
pToken.Chave = i;
pToken.tamanho = strlen(token);
pToken.plv = (char*) malloc( pToken.tamanho + 1 * sizeof(char) );
// copia o conteudo do token para o pToken
strcpy( pToken.plv , token);
//insere palavra na lista
Insere(pToken, lista);
// processa o proximo token
token = strtok(NULL, delim);
}
}
void * produtor (void * args) {
int i;
for (i = 0; i < 25; i++) Insere(fibo(i), i + 1);
pthread_exit(NULL);
}
void OrdenaLista(Apontador * ponteiros, TipoLista palavras, int tabelaAsc[256], TipoLista * resultado){
int i=0, j=0;
Apontador aux;
TipoItem item;
aux=palavras.Primeiro->Prox;
while(aux!=NULL){
ponteiros[i]=aux;
i++;
aux=aux->Prox;
}
i--;//PASSAR A CASA FINAL DO VETOR CERTA
QuickSort(ponteiros, &i, tabelaAsc);
while(i>=0){
strcpy(item.palavra, ponteiros[j]->Item.palavra);
item.numVezes=1;
if(strcmp(resultado->Ultimo->Item.palavra, item.palavra)==0)
resultado->Ultimo->Item.numVezes++;
else
Insere(item, resultado);
i--;
j++;
}
}
void semaphoreP(){
int i=0, achou=0;
printf("Verificação dos semaforos ....\n");
sem_wait(&semProcessos);
while(listaSemaforos[i]!='\0'){
if(listaSemaforos[i]==sem){
achou = 1;
}
i++;
}
if(achou == 1){
printf("Processo em espera ... \n");
emEspera = Insere(emEspera,Dados.PID,Dados.Prioridade);
}else{
listaSemaforos[i] = sem;
listaSemaforos[i+1]='\0';
printf("O semaforo %c foi bloqueado ... \n", sem);
}
sem_post(&semProcessos);
}
void Menu()
{
int op;
FILE *arquivo;
struct prod *Lista= (struct prod *)malloc(sizeof(struct prod));
Lista->prox =NULL;
Lista->ant =NULL;
AbrirArquivo(Lista,arquivo );
while(1)
{
system("cls");
printf("0 - Abrir Arquivo\n");
printf("1 - Insere\n");
printf("2 - Exibe\n");
printf("3 - Apaga\n");
printf("4 - Pesquiar\n");
printf("5 - Salvar\n");
printf("Informe Opcao: ");
scanf("%d", &op);
system("cls");
switch (op)
{
case 1:
{
Insere(Lista);
break;
}
case 2:
{
Exibe(Lista);
break;
}
case 3:
{
Apaga(Lista);
break;
}
case 4:
{
Pesquisar(Lista);
break;
}
case 5:
{
SalvaArquivo(Lista,arquivo );
break;
}
default:
{
break;
}
}
}
return;
}
void ArbreBinaire::Insere(Noeud* parent, Noeud* actuel, int valeur) {
if(actuel == 0) {
// On a trouve le point d'insertion, alors on insere le noeud
if (valeur < parent->valeur) {
parent->gauche = new Noeud(valeur);
} else {
parent->droite = new Noeud(valeur);
}
} else {
// On insere dans la bonne branche de l'arbre
if (valeur < actuel->valeur) {
Insere(actuel, actuel->gauche, valeur);
} else {
Insere(actuel, actuel->droite, valeur);
}
}
}
void processFinish(){
sem_wait(&semEscalonador);
puts("Processo Terminou");
puts("Adicionando processos a lista de terminados ...");
Prontos = Remove(Prontos);
terminados = Insere(terminados,Dados.PID,Dados.Prioridade);
}
void ArbreBinaire::Insere(int valeur) {
// S'il n'y a pas de racine, on insere la valeur comme racine
if(racine == 0) {
racine = new Noeud(valeur);
} else {
// Sinon, on insere de facon recursive
Insere(0, racine, valeur);
}
}
void processInterrupt(){
printf("Interrupcao pelo fim do quantum ... retornando processo a fila ...\n\n");
switch(Dados.Prioridade){
case 1:
Fila1 = Insere(Fila1,Dados.PID,Dados.Prioridade); break;
case 2:
Fila2 = Insere(Fila2,Dados.PID,Dados.Prioridade); break;
case 3:
Fila3 = Insere(Fila3,Dados.PID,Dados.Prioridade); break;
case 4:
Fila4 = Insere(Fila4,Dados.PID,Dados.Prioridade); break;
case 5:
Fila5 = Insere(Fila5,Dados.PID,Dados.Prioridade); break;
}
}
void processCreate(){
printf("Criando processos e adicionando na lista de prontos:\n");
Prontos = Insere(Prontos,Dados.PID,Dados.Prioridade);
printf("Processos na lista de prontos:\n");
Print(Prontos);
puts("Colocando o processo na fila de acordo com suas prioridades ... \n ");
switch (Dados.Prioridade){
case 1:
Fila1 = Insere(Fila1,Dados.PID,Dados.Prioridade);
printf("Inserido na fila 1 \n");
break;
case 2:
Fila2 = Insere(Fila2,Dados.PID,Dados.Prioridade);
printf("Inserido na fila 2 \n");
break;
case 3:
Fila3 = Insere(Fila3,Dados.PID,Dados.Prioridade);
printf("Inserido na fila 3 \n");
break;
case 4:
Fila4 = Insere(Fila4,Dados.PID,Dados.Prioridade);
printf("Inserido na fila 4");
break;
case 5:
Fila5 = Insere(Fila5,Dados.PID,Dados.Prioridade);
break;
}
sem_post(&semEscalonador);
}
int main()
{
FILE *arq;
char Autor[30],Editora[30];
List *segAutor,*segEditora;
//Indice aut_ind,edi_ind;
//aut_ind.tam=-1;
//guardar no arquivo a quantidade de registro salvo.
//verifica se arquivo existe, se não existir cria e coloca topo = -1
arq = fopen("BD_livros2.bin", "rb+");
if( arq == NULL )
{ printf("Entrou\n");
int aux=-1;
arq = fopen("BD_livros2.bin", "wb+");
fwrite(&aux,sizeof(int), 1, arq);
}
fclose(arq);
int tamanho =0 ;
char op='s';
while( op != '9' )
{
tamanho =Tamanho_Arquivos();
printf("Tam-agora %d\n",tamanho);
//se ainda não inicializou e tamanho > 10
/* if( tamanho>=10 && aut_ind.tam==-1)
{
//aut_ind = Cria_Indice_Autor(tamanho);
//edi_ind = Cria_Indice_Autor(tamanho);
}*/
printf("\n**************************\n");
printf(" MENU\n");
printf("**************************\n\n");
printf("1-Inserir Livro\n");
printf("2-Pesquisa Ano\n");
printf("3-Listar\n");
printf("4-Pesquisa Autor\n");
printf("5-Pesquisa Editora\n");
printf("6-Pesquisa Autor e Editora\n");
printf("7-Pesquisa Autor ou Editora\n");
printf("8-Remove\n");
printf("9-Sair\n\n\n");
//printf("Topo pilha %d\n",getTopo());
printf("Opcao Desejada: ");
setbuf(stdin,NULL);
scanf(" %c",&op);
///criar o indice somente quando chegar a 10.
if (op == '1')
{
setbuf(stdin,NULL);
Livro L;
// Ler_dados_livro(&L);
// InsereUmLivro(L);
Insere();
tamanho =Tamanho_Arquivos();
}
else if(op == '2')
{
int ano;
printf("Ano: ");
scanf("%d",&ano);
setbuf(stdin,NULL);
Pesquisa_ano(ano);
}
else if(op == '3')
{
Listar();
}
else if(op == '4')
{
scanf("%s",Autor);
//chamar função
}
else if(op == '5')
{
scanf("%s",Editora);
}
else if(op == '6')
{
printf("Autor: ");
scanf("%s",Autor);
printf("Editora: ");
scanf("%s",Editora);
}
else if(op == '7')
{
printf("Autor: ");
scanf("%s",Autor);
printf("Editora: ");
scanf("%s",Editora);
}
else if(op == '8')
{
Remove_registro(0);
//Remove_registro(25);
//Remove_registro(48);
}
setbuf(stdin,NULL);
}
return 0;
/*
List * Lista;
Lista = CriaLista();
InserirLista(Lista, 2);
InserirLista(Lista, 1);
InserirLista(Lista, 3);
Ordena(&Lista->Primeiro, (FuncaoComparacao) ComparaChavePrimaria);
printf("%d", Lista->Primeiro->Proximo->Info);
RemoverLista(Lista, (FuncaoComparacao) ComparaChave, 2);
printf("%d", Lista->Primeiro->Proximo->Info);
*/
}
//=========================FUNÇÃO PRINCIPAL===================================
int main(){
system("title Controle De Estoque 2011");
system("color 0f");
int op,z,d,i,k;
char resp,c;
TipoItem item;
TipoLista Lista;
ApontadorNo Arvore_cod;
IniciarLista(&Lista);
Inicializa(&Arvore_cod);
i=0;
do{
menu();
scanf("%d",&op);
system("cls");
if(op==1){
do{
printf("\t\tGERENCIAMENTO DE ESTOQUE\n\n\tINCLUSAO DE NOVO CADASTRO\n\n");
fflush(stdin);
printf("Digite o codigo do produto: ");
scanf("%d",&item.cod);
printf("\nDigite o nome do produto: ");
fflush(stdin);
gets(&item.nome[i]);
printf("\nDigite o valor: ");
fflush(stdin);
scanf("%f",&item.valor);
printf("\nDigite o fabricante: ");
fflush(stdin);
gets(&item.fabri[i]);
printf("\nDigite a quantidade: ");
fflush(stdin);
scanf("%d",&item.quantidade);
InserirCelula(&Lista,item);
printf("\n\tDeseja digita novamente? (S/N).:");
fflush(stdin);
Insere(item,&Arvore_cod);
scanf("%c",&resp);
system("cls");
}while(resp=='s');
system("cls");
}
if(op==2){
printf("\t\t\tESTOQUE\n");
ImprimeLista(Lista);
system("pause");
system("cls");
}
if(op==3){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
ImprimeLista(Lista);
do{
printf("\n\tQual deseja remover.:");
scanf("%d",&k);
if(Verificar(k,Lista)==1){
fflush(stdin);
RetiraL(k,&Lista,&item);
fflush(stdin);
Retira(item, &Arvore_cod);
fflush(stdin);
printf("\n\tDeseja Remover novamente? (S/N).:");
fflush(stdin);
scanf("%c",&resp);
}
}while(resp=='s');
system("pause");
system("cls");
}
}
if(op==4){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
printf("\t\tOrdenado por valor\n");
d=Tamanho(Lista);
QuickSortLista(&Lista,d);
ImprimeLista(Lista);
system("pause");
system("cls");
}
}
if(op==5){
if(TesteListaVazia(Lista)){
ImprimeLista(Lista);
system("pause");
system("cls");
}
else{
printf("\n\n\n Digite o codigo que deseja encontrar: ");
scanf("%d", &item.cod);
fflush(stdin);
Pesquisa(&item, &Arvore_cod, item.quantidade);
printf("\n");
system("pause");
}
system("cls");
}
if(op==6){
}
if(op==7){
}
if(op==8){
}
if(op==9){
}
if(op<1||op>10){
system("color 4f");
printf("\tOpcao Invalida\n");
system("pause");
system("cls");
system("color 0f");
}
else if(op==10){
exit(1);
}
}while(op>0||op<10);
}
list New_share(list head, int ID){
return Insere(head, ID);
}
void InsereAresta(int *V1, int *V2, TipoGrafo *Grafo){
TipoItem x;
x.Vertice = *V2;
Insere(&x, &Grafo->Adj[*V1]);
}
void escalonar(int tempoExec){
int i=0;
sem_wait(&semEscalonador);
if(tempoExec > 0){
printf("#-----------------------------------------------------------------------------------------#\n");
printf("#-----------------------------------------------------------------------------------------#\n\n");
if(executando == 0){
printf("Iniciando execução \n");
executando = 1;
switch(Dados.Prioridade){
case 1:
Fila1 = Remove(Fila1);
emExecucao = Insere(emExecucao,Dados.PID,Dados.Prioridade);
printf("Executando processo por 100 ut \n");
for(i=0;i<3;i++){
printf("Executando processo ... \n");
sleep(2);
}
tempoExec = tempoExec - 100;
emExecucao = Remove(emExecucao);
if(tempoExec > 0){
trataInterrupcao(1);
}else{
trataInterrupcao(3);
}
break;
case 2:
Fila2 = Remove(Fila2);
emExecucao = Insere(emExecucao,Dados.PID,Dados.Prioridade);
printf("Executando processo por 200 ut \n");
for(i=0;i<3;i++){
printf("Executando processo ... \n");
sleep(2);
}
tempoExec = tempoExec - 200;
emExecucao = Remove(emExecucao);
if(tempoExec > 0){
trataInterrupcao(1);
}else{
trataInterrupcao(3);
}
break;
case 3:
Fila3 = Remove(Fila3);
emExecucao = Insere(emExecucao,Dados.PID,Dados.Prioridade);
printf("Executando processo por 400 ut \n");
for(i=0;i<3;i++){
printf("Executando processo ... \n");
sleep(2);
}
tempoExec = tempoExec - 400;
emExecucao = Remove(emExecucao);
if(tempoExec > 0){
trataInterrupcao(1);
}else{
trataInterrupcao(3);
}
break;
case 4:
Fila2 = Remove(Fila2);
emExecucao = Insere(emExecucao,Dados.PID,Dados.Prioridade);
printf("Executando processo por 600 ut \n");
for(i=0;i<3;i++){
printf("Executando processo ... \n");
sleep(2);
}
tempoExec = tempoExec - 600;
emExecucao = Remove(emExecucao);
if(tempoExec > 0){
trataInterrupcao(1);
}else{
trataInterrupcao(3);
}
break;
case 5:
Fila2 = Remove(Fila2);
emExecucao = Insere(emExecucao,Dados.PID,Dados.Prioridade);
printf("Executando processo por 100 ut \n");
for(i=0;i<3;i++){
printf("Executando processo ... \n");
sleep(2);
}
tempoExec = tempoExec - 100;
emExecucao = Remove(emExecucao);
if(tempoExec > 0){
trataInterrupcao(1);
}else{
trataInterrupcao(3);
}
break;
}
}
executando=0;
sem_post(&semEscalonador);
}
sem_post(&semEscalonador);
}
int LeArquivo(char * entrada, int tabelaAsc[256], TipoLista * palavras){
FILE *fpEntrada;
int i, ascAux, numPalavras;
char aux[2], confere[MAXTAM], palavraCorrigida[MAXTAM];
TipoItem item;
fpEntrada=fopen(entrada, "r");
fscanf(fpEntrada, "%s", confere);
if(strcasecmp(confere, "ORDEM")==0){
for(i=0;i<26;i++){
fscanf(fpEntrada, "%s", aux);
StrLower(aux);
ascAux=ConverteCharAsc(aux);
tabelaAsc[ascAux]=i+97;//POSICAO CORERETA NA TABELA AUX PASSADA
}
fscanf(fpEntrada, "%s", confere);// LE "TEXTO" E GUARDA EM CONFERE
numPalavras=0;
while (fscanf(fpEntrada, "%s", confere) != EOF){
strcpy(palavraCorrigida,"");//ESVAZIA PALAVRACORRIGIDA
Tokeniza(confere, palavraCorrigida);
if(palavraCorrigida[strlen(palavraCorrigida)-1]=='-' && strlen(palavraCorrigida)>1){//Se o último caracter for hífen e a palavra não for "-"
if(fscanf(fpEntrada, "%s", confere) != EOF){
Tokeniza(confere, palavraCorrigida);
}
}
StrLower(palavraCorrigida);
strcpy(item.palavra, palavraCorrigida);//item.palavra=confere
item.numVezes=1;
Insere(item, palavras);//Cria celula para a palavra;
numPalavras++;//NUMERO DE PALAVRAS INSERIDAS NA LISTA
}//WHILE
} else {//LOGO A PRIMEIRA PALAVRA SERÁ TEXTO
fscanf(fpEntrada, "%s", confere);
numPalavras=0;//Ja foi inserida a primeira palavra
while(strcasecmp(confere, "ORDEM")!=0){
strcpy(palavraCorrigida,"");//ESVAZIA PALAVRACORRIGIDA
Tokeniza(confere, palavraCorrigida);
if(palavraCorrigida[strlen(palavraCorrigida)-1]=='-' && strlen(palavraCorrigida)>1){//Se o último caracter for hífen e a palavra não for "-"
fscanf(fpEntrada, "%s", confere);//Le a prox palavra
if(strcasecmp(confere, "ORDEM")!=0){
Tokeniza(confere, palavraCorrigida);
}
}
StrLower(palavraCorrigida);
strcpy(item.palavra, palavraCorrigida);//item.palavra=confere
item.numVezes=1;
Insere(item, palavras);//Cria celula para a palavra;
numPalavras++;//NUMERO DE PALAVRAS INSERIDAS NA LISTA
if(strcmp(confere, "ORDEM")!=0)
fscanf(fpEntrada, "%s", confere);
}//WHILE
for(i=0;i<26;i++){
fscanf(fpEntrada, "%s", aux);
StrLower(aux);
ascAux=ConverteCharAsc(aux);
tabelaAsc[ascAux]=i+97;//POSICAO CORERETA NA TABELA AUX PASSADA
}
}//ELSE
return numPalavras;
fclose(fpEntrada);
}
void Push (int ID){
stack_S = Insere(stack_S, ID);
}
int main(int argc, char *argv[])
{
struct timeval t;
No *Dicionario;
Registro x;
TipoChave vetor[max];
int i, j, k, n;
Inicializa(&Dicionario);
/* Gera uma permutação aleatoria de chaves entre 1 e max */
for (i = 0; i < max; i++)
vetor[i] = i+1;
//gettimeofday(&t,NULL);
srand((unsigned int)t.tv_usec);
Permut(vetor,max-1);
/* Insere cada chave na arvore e testa sua integridade apos cada insercao */
for (i = 0; i < max; i++)
{ x.Chave = vetor[i];
Insere(x, &Dicionario);
printf("Inseriu chave: %d\n", x.Chave);
Testa(Dicionario);
getchar();
}
NotaText(Dicionario);
getchar();
/* Retira uma chave aleatoriamente e realiza varias pesquisas */
for (i = 0; i <= max; i++)
{ k = (int) (10.0*rand()/(RAND_MAX+1.0));
n = vetor[k];
x.Chave = n;
Retira(x, &Dicionario);
Testa(Dicionario);
printf("Retirou chave: %ld\n", x.Chave);
for (j = 0; j < max; j++)
{ x.Chave = vetor[(int) (10.0*rand()/(RAND_MAX+1.0))];
if (x.Chave != n)
{ printf("Pesquisando chave: %ld\n", x.Chave);
Pesquisa(&x, &Dicionario);
}
}
x.Chave = n;
Insere(x, &Dicionario);
printf("Inseriu chave: %ld\n", x.Chave);
Testa(Dicionario);
}
/* Retira a raiz da arvore ate que ela fique vazia */
for (i = 0; i < max; i++)
{ x.Chave = Dicionario->Reg.Chave;
Retira(x, &Dicionario);
Testa(Dicionario);
printf("Retirou chave: %ld\n", x.Chave);
}
getchar();
return 0;
}
int main(){
char labelConj; // rotulo do conjunto empregado nas operacoes
int erro; // flag de erro na criacao dos conjuntos
int Opcao; // operacao escolhida pelo usuario
Conjunto *A, *B, *C;
elem valor, min, max;
// conjunto A
A = CriaConjVazio(&erro);
if (erro){
printf("Erro de alocacao!\n");
exit(1);
}
// conjunto B
B = CriaConjVazio(&erro);
if (erro){
printf("Erro de alocacao!\n");
exit(1);
}
// conjunto C onde serao armazenados os resultados das operacoes
C = CriaConjVazio(&erro);
if (erro){
printf("Erro de alocacao!\n");
exit(1);
}
//Enquanto Opcao for diferente de SAIR.
do {
//Pergunta a Opcao que o usuario deseja realizar.
scanf("%d", &Opcao);
//Verifica qual Opcao foi escolhida.
switch (Opcao) {
// Opcao 1
case INSERCAO:
scanf("%d \n%c", &valor, &labelConj);
if (labelConj == 'A') //insere em A
if (Insere(valor, A) == FALSO) //se der problema
printf(FRASE_ELEM_INVALIDO); //imprime frase
else {
printf("A = ");
Imprimir(A);
}
else if (labelConj == 'B') // insere em B
if (Insere(valor, B) == FALSO)
printf(FRASE_ELEM_INVALIDO);
else {
printf("B = ");
Imprimir(B);
}
else
printf(FRASE_ERRO);
break;
// Opcao 2
case REMOCAO:
scanf("%d \n%c", &valor, &labelConj);
if (labelConj == 'A') // remove de A
if (Remove(valor, A) == FALSO) //se der problema
printf(FRASE_ELEM_NAOENCONTRADO); //imprime frase
else {
printf("A = ");
if (TestaVazio(A)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(A);
}
}
else if (labelConj == 'B') // remove de B
if (Remove(valor, B) == FALSO)
printf(FRASE_ELEM_NAOENCONTRADO);
else {
printf("B = ");
if (TestaVazio(B)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(B);
}
}
else
printf(FRASE_ERRO);
break;
// Opcao 3
case MEMBRO:
scanf("%d \n%c", &valor, &labelConj);
if (labelConj == 'A') // procura em A
if (Membro(valor, A) == FALSO) //se der problema
printf(FRASE_FALSO); //imprime frase
else
printf(FRASE_VERDADEIRO); //imprime frase
else if (labelConj == 'B') // procura em B
if (Membro(valor, B) == FALSO)
printf(FRASE_FALSO);
else
printf(FRASE_VERDADEIRO);
else
printf(FRASE_ERRO);
break;
// Opcao 4
case TAMANHO:
scanf("\n%c", &labelConj);
if (labelConj == 'A') // verifica A
printf("%d\n", Tamanho(A));
else if (labelConj == 'B') // verifica B
printf("%d\n", Tamanho(B));
else
printf(FRASE_ERRO);
break;
// Opcao 5
case IMPRESSAO:
printf("A = ");
if (TestaVazio(A)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(A);
}
printf("B = ");
if (TestaVazio(B)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(B);
}
break;
// Opcao 6
case MINIMO:
scanf("\n%c", &labelConj);
if (labelConj == 'A') { // verifica A
min = Min(A);
if (min == TAM) // se conjunto vazio
printf(FRASE_CONJ_VAZIO); // imprime frase
else
printf("%d\n", min); //imprime frase
} else if (labelConj == 'B') { // verifica B
min = Min(B);
if (min == TAM) // se conjunto vazio
printf(FRASE_CONJ_VAZIO); // imprime frase
else
printf("%d\n", min); //imprime frase
} else
printf(FRASE_ERRO);
break;
// Opcao 7
case MAXIMO:
scanf("\n%c", &labelConj);
if (labelConj == 'A') { // verifica A
max = Max(A);
if (max == TAM) // se conjunto vazio
printf(FRASE_CONJ_VAZIO); // imprime frase
else
printf("%d\n", max); //imprime frase
} else if (labelConj == 'B') { // verifica B
max = Max(B);
if (max == TAM) // se conjunto vazio
printf(FRASE_CONJ_VAZIO); // imprime frase
else
printf("%d\n", max); //imprime frase
} else
printf(FRASE_ERRO);
break;
// Opcao 8
case UNIAO:
Inicializar(C);
Uniao(A, B, C);
if (TestaVazio(C)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(C);
}
break;
// Opcao 9
case INTERSECCAO:
Inicializar(C);
Interseccao(A, B, C);
if (TestaVazio(C)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(C);
}
break;
// Opcao 10
case DIFERENCA:
Inicializar(C);
Diferenca(A, B, C);
if (TestaVazio(C)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(C);
}
break;
// Opcao 11
case IGUAL:
if (Igual(A, B) == FALSO)
printf(FRASE_FALSO);
else
printf(FRASE_VERDADEIRO);
break;
// Opcao 12
case COPIA:
Copia(A, B);
printf("A = ");
if (TestaVazio(A)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(A);
}
printf("B = ");
if (TestaVazio(B)) {
printf(FRASE_CONJ_VAZIO);
} else {
Imprimir(B);
}
break;
// Opcao 13
case SAIR:
Libera(A);
Libera(B);
Libera(C);
break;
}
} while (Opcao != SAIR);
return (0);
}
