listas simples/vetores para conjuntos numéricos

andrecavalcanti · Abril 16, 2015

Acredito que para fazer é preciso usar listas simples. AInda não estudamos isso, mas estou com a impressão de que a intenção do professor era que pesquisássemos para ao menos tentar fazer...

.

O programa deverá manter dois conjuntos matemáticos, que podem crescer e

decrescer dinamicamente através da inclusão e remoção de elementos em cada um

dos conjuntos. Além disso, o programa deve, iterativamente, a qualquer tempo, pela

escolha do usuário através de um menu, proceder ao cálculo e a impressão das

operações sobre conjunto.

Espera-se que o programa forneça as seguintes operações:

 Inserção de elemento no primeiro conjunto

 Inserção de elemento no segundo conjunto

 Remoção de elemento do primeiro conjunto

 Remoção de elemento do segundo conjunto

 Impressão do primeiro conjunto

 Impressão do segundo conjunto

 Cálculo e impressão da união entre os conjuntos

 Cálculo e impressão da interseção entre conjuntos

 Cálculo e impressão da diferença entre conjuntos

 Cálculo e impressão se o primeiro conjunto está contido no segundo conjunto

 Cálculo e impressão se o segundo conjunto está contido no primeiro conjunto

 Cálculo e impressão se os conjuntos são iguais

 Cálculo e impressão se um dado elemento pertence ao primeiro conjunto

 Cálculo e impressão se um dado elemento pertence ao segundo conjunto

Considere que a quantidade máxima de elementos de cada conjunto é igual a 100.

Sugere-se o uso de um registro (struct) para a representação do conjunto.

Tentei com vetores, mas não sei como fazer o tamanho flexível para inserir e remover elementos...falta colocar o switch case com o menu nem declarei o conjunto por struct ainda (sei como fazer) e as últimas operações. Mas o que tá pegando mais é esse início mesmo, o tamanho flexível, remoção e adição. Acho que a intenção do professor era que pesquisássemos e tentássemos usar lista simples, que um assunto ainda não dado, mas eu pesquisei e tetei começar algo também. Seguem os dois códigos iniciais:

#include <stdio.h>

#include <stdlib.h>

int main()

{

int x[100],y[100],u[100],d[100],s[100],p[100],it[100];

int i,j,k,cont_u,cont_d,cont_i;

// Leitura dos conjuntos X,Y

for(i=0;i<100;i++){

printf("x[%i]:",i+1);

scanf("%i",&x);

}

for(i=0;i<100;i++){

printf("y[%i]:",i+1);

scanf("%i",&y);

}

cont_u=0;

cont_i=0;

cont_d=0;

for(i=0;i<100;i++){

j=0;

while(j < cont_u && x!= u[j]){

j=j+1;

}

if (j >= cont_u){

u[cont_u] = x;

cont_u=cont_u+1;

}

for(i=0;i<100;i++){

j=0;

while(j < cont_u && y!= u[j]){

j=j+1;

}

if(j >= cont_u){

u[cont_u]=y;

cont_u=cont_u+1;

}

printf("\nUNIAO:\n");

for(i=0;i<cont_u;i++){

printf(" %i ", u);

}

for(i=0;i<100;i++){

j=0;

while(x!= y[j] && j < 100){

j=j+1;

}

if(j>=100){

k=0;

while(k <= cont_d && x!= d[k]){

k=k+1;

}

if(k >= cont_d){

d[cont_d] = x;

cont_d = cont_d + 1;

}

printf("\n DIFERENCA:\n ");

for(i=0;i<cont_d;i++){

printf(" %i ", d);

}

for(i=0;i<100;i++){

s=x+y;

p=x*y;

}

printf("\nUNIAO:\n");

for(i=0;i<100;i++){

printf(" %i " , s);

}

printf("\nPRODUTO:\n");

for(i=0;i<100;i++){

printf(" %i " , p);

}

for (i=0;i<100;i++)

{

j = 0;

while (j < 100 && x != y[j])

{

j++;

}

if (j < 100)

{

k = 0;

while (k < cont_i && it[k] != x)

{

k++;

}

if (k >= cont_i)

{ it[cont_i] = x;

cont_i++;

}

printf("\n INTERSECCAO: \n");

for(i=0;i<cont_i;i++){

printf(" %i ", it);

}

printf("\n\n\n\n\n\n");

system("pause");

}

Tentando por listas, só consegui declarar um conjunto e algumas operações, pois não sei o assunto direito. Queria pelo menos conseguir colocar a lista para o conjunto 2. Tem como aproveitar as funções de remoção e inserção que já estão para o conjunto1?

#include <stdio.h>

#include <stdlib.h>

int main()

{

int x[100],y[100],u[100],d[100],s[100],p[100],it[100];

int i,j,k,cont_u,cont_d,cont_i;

// Leitura dos conjuntos X,Y

for(i=0;i<100;i++){

printf("x[%i]:",i+1);

scanf("%i",&x);

}

for(i=0;i<100;i++){

printf("y[%i]:",i+1);

scanf("%i",&y);

}

cont_u=0;

cont_i=0;

cont_d=0;

for(i=0;i<100;i++){

j=0;

while(j < cont_u && x!= u[j]){

j=j+1;

}

if (j >= cont_u){

u[cont_u] = x;

cont_u=cont_u+1;

}

for(i=0;i<100;i++){

j=0;

while(j < cont_u && y!= u[j]){

j=j+1;

}

if(j >= cont_u){

u[cont_u]=y;

cont_u=cont_u+1;

}

printf("\nUNIAO:\n");

for(i=0;i<cont_u;i++){

printf(" %i ", u);

}

for(i=0;i<100;i++){

j=0;

while(x!= y[j] && j < 100){

j=j+1;

}

if(j>=100){

k=0;

while(k <= cont_d && x!= d[k]){

k=k+1;

}

if(k >= cont_d){

d[cont_d] = x;

cont_d = cont_d + 1;

}

printf("\n DIFERENCA:\n ");

for(i=0;i<cont_d;i++){

printf(" %i ", d);

}

for(i=0;i<100;i++){

s=x+y;

p=x*y;

}

printf("\nUNIAO:\n");

for(i=0;i<100;i++){

printf(" %i " , s);

}

printf("\nPRODUTO:\n");

for(i=0;i<100;i++){

printf(" %i " , p);

}

for (i=0;i<100;i++)

{

j = 0;

while (j < 100 && x != y[j])

{

j++;

}

if (j < 100)

{

k = 0;

while (k < cont_i && it[k] != x)

{

k++;

}

if (k >= cont_i)

{ it[cont_i] = x;

cont_i++;

}

printf("\n INTERSECCAO: \n");

for(i=0;i<cont_i;i++){

printf(" %i ", it);

}

printf("\n\n\n\n\n\n");

system("pause");

}

_Isis_ · Abril 16, 2015

Por listas simples entende-se uma estrutura que contém o endereço do próximo elemento da lista (lista encadeada). Se a turma já passou pelo assunto de alocação dinâmica e foi mencionado por cima como uma lista encadeada funciona, é relativamente fácil fazer.

Arrays declarados dessa forma são estáticos.

O reaproveitamento das funções pode ser feito se elas forem implementadas da forma correta.

andrecavalcanti · Abril 16, 2015

Por listas simples entende-se uma estrutura que contém o endereço do próximo elemento da lista (lista encadeada). Se a turma já passou pelo assunto de alocação dinâmica e foi mencionado por cima como uma lista encadeada funciona, é relativamente fácil fazer.

Não vimos alocação dinâmica rs. Por isso a dificuldade, estou tendo que descobrir como funciona através de pesquisa...
Estudamos somente até matrizes... EU acabei postando duas vezes a tentativa por arrays...Eu fiquei sem saber como fazer para colocar o segundo conjunto e ele aparecer embaixo e nem a comparação.

#include <stdio.h>
#include <stdlib.h>

struct Elemento{
        int num;
        struct Elemento *prox;
};
typedef struct Elemento elemento;

int tam;

void inicia(elemento *CONJUNTO1);
int menu(void);
void opcao(elemento *CONJUNTO1, int op);
elemento *criaNo();
void insereFim(elemento *CONJUNTO1);
void insereInicio(elemento *CONJUNTO1);
void exibe(elemento *CONJUNTO1);
void libera(elemento *CONJUNTO1);
void insere (elemento *CONJUNTO1);
elemento *retiraInicio(elemento *CONJUNTO1);
elemento *retiraFim(elemento *CONJUNTO1);
elemento *retira(elemento *CONJUNTO1);


int main(void)
{
        elemento *CONJUNTO1 = (elemento *) malloc(sizeof(elemento));
        if(!CONJUNTO1){
               printf("Sem memoria disponivel!\n");
               exit(1);
        }else{
        inicia(CONJUNTO1);
        int opt;
       
        do{
               opt=menu();
               opcao(CONJUNTO1,opt);
        }while(opt);

        free(CONJUNTO1);
        return 0;
        }
}

void inicia(elemento *CONJUNTO1)
{
        CONJUNTO1->prox = NULL;
        tam=0;
}

int menu(void)
{
        int opt;
       
        printf("Escolha a opcao\n");
        printf("0. Sair\n");
        printf("1. Zerar Conjunto 1\n");
        printf("2. Exibir Conjunto 1\n");
        printf("3. Adicionar elemento no inicio\n");
        printf("4. Adicionar elemento no final\n");
        printf("5. Escolher onde inserir\n");
        printf("6. Retirar do inicio\n");
        printf("7. Retirar do fim\n");
        printf("8. Escolher de onde tirar\n");
        printf("Opcao: "); scanf("%d", &opt);
       
        return opt;
}

void opcao(elemento *CONJUNTO1, int op)
{
        elemento *tmp;
        switch(op){
               case 0:
                       libera(CONJUNTO1);
                       break;
                      
               case 1:
                       libera(CONJUNTO1);
                       inicia(CONJUNTO1);
                       break;
              
               case 2:
                       exibe(CONJUNTO1);
                       break;
              
               case 3:
                       insereInicio(CONJUNTO1);
                       break;        
                      
               case 4:
                       insereFim(CONJUNTO1);
                       break;
                      
               case 5:
                       insere(CONJUNTO1);
                       break;
              
               case 6:
                       tmp= retiraInicio(CONJUNTO1);
                       printf("Retirado: %3d\n\n", tmp->num);
                       break;
                      
               case 7:
                       tmp= retiraFim(CONJUNTO1);
                       printf("Retirado: %3d\n\n", tmp->num);
                       break;
              
               case 8:
                       tmp= retira(CONJUNTO1);
                       printf("Retirado: %3d\n\n", tmp->num);
                       break;
              
               default:
                       printf("Comando invalido\n\n");
        }
}

int vazia(elemento *CONJUNTO1)
{
        if(CONJUNTO1->prox == NULL)
               return 1;
        else
               return 0;
}

elemento *aloca()
{
        elemento *novo=(elemento *) malloc(sizeof(elemento));
        if(!novo){
               printf("Sem memoria disponivel!\n");
               exit(1);
        }else{
               printf("Novo elemento: "); scanf("%d", &novo->num);
               return novo;
        }
}


void insereFim(elemento *CONJUNTO1)
{
        elemento *novo=aloca();
        novo->prox = NULL;
       
        if(vazia(CONJUNTO1))
               CONJUNTO1->prox=novo;
        else{
               elemento *tmp = CONJUNTO1->prox;
              
               while(tmp->prox != NULL)
                       tmp = tmp->prox;
              
               tmp->prox = novo;
        }
        tam++;
}

void insereInicio(elemento *CONJUNTO1)
{
        elemento *novo=aloca();       
        elemento *oldHead = CONJUNTO1->prox;
       
        CONJUNTO1->prox = novo;
        novo->prox = oldHead;
       
        tam++;
}

void exibe(elemento *CONJUNTO1)
{
        system("clear");
        if(vazia(CONJUNTO1)){
               printf("Lista vazia!\n\n");
               return ;
        }
       
        elemento *tmp;
        tmp = CONJUNTO1->prox;
        printf("Lista:");
        while( tmp != NULL){
               printf("%5d", tmp->num);
               tmp = tmp->prox;
        }
        printf("\n        ");
        int count;
        for(count=0 ; count < tam ; count++)
               printf("  ^  ");
        printf("\nOrdem:");
        for(count=0 ; count < tam ; count++)
               printf("%5d", count+1);
       
              
        printf("\n\n");
}

void libera(elemento *CONJUNTO1)
{
        if(!vazia(CONJUNTO1)){
               elemento *proxElemento,
                         *atual;
              
               atual = CONJUNTO1->prox;
               while(atual != NULL){
                       proxElemento = atual->prox;
                       free(atual);
                       atual = proxElemento;
               }
        }
}

void insere(elemento *CONJUNTO1)
{
        int pos,
               count;
        printf("Em que posicao, [de 1 ate %d] voce deseja inserir: ", tam);
        scanf("%d", &pos);
       
        if(pos>0 && pos <= tam){
               if(pos==1)
                       insereInicio(CONJUNTO1);
               else{
                       elemento *atual = CONJUNTO1->prox,
                                *anterior=CONJUNTO1;
                       elemento *novo=aloca();
                                
                       for(count=1 ; count < pos ; count++){
                                      anterior=atual;
                                      atual=atual->prox;
                       }
                       anterior->prox=novo;
                       novo->prox = atual;
                       tam++;
               }
                      
        }else
               printf("Elemento invalido\n\n");             
}

elemento *retiraInicio(elemento *CONJUNTO1)
{
        if(CONJUNTO1->prox == NULL){
               printf("Lista ja esta vazia\n");
               return NULL;
        }else{
               elemento *tmp = CONJUNTO1->prox;
               CONJUNTO1->prox = tmp->prox;
               tam--;
               return tmp;
        }
                              
}

elemento *retiraFim(elemento *CONJUNTO1)
{
        if(CONJUNTO1->prox == NULL){
               printf("Lista ja vazia\n\n");
               return NULL;
        }else{
               elemento *ultimo = CONJUNTO1->prox,
                        *penultimo = CONJUNTO1;
                        
               while(ultimo->prox != NULL){
                       penultimo = ultimo;
                       ultimo = ultimo->prox;
               }
                        
               penultimo->prox = NULL;
               tam--;
               return ultimo;        
        }
}

elemento *retira(elemento *CONJUNTO1)
{
        int opt,
               count;
        printf("Que posicao, [de 1 ate %d] voce deseja retirar: ", tam);
        scanf("%d", &opt);
       
        if(opt>0 && opt <= tam){
               if(opt==1)
                       return retiraInicio(CONJUNTO1);
               else{
                       elemento *atual = CONJUNTO1->prox,
                                *anterior=CONJUNTO1;
                                
                       for(count=1 ; count < opt ; count++){
                               anterior=atual;
                               atual=atual->prox;
                       }
                      
               anterior->prox=atual->prox;
               tam--;
               return atual;
               }
                      
        }else{
               printf("Elemento invalido\n\n");
               return NULL;
        }
}

andrecavalcanti · Abril 20, 2015

Estou a fazer um trabalho sobre listas, não vimos este assunto ainda no curso e estou pesquisando para fazer. O trabalho consiste em declarar DOIS conjuntos numéricos, colocar um menu com as opções de inserir, remover e depois vamos ter que colocar as operações de conjuntos ( intersecção etc)...

A minha dificuldade deve ser meio ridícula para quem já sabe, eu estou sem saber como colocar DOIS conjuntos, como fazer a declaração de um segundo conjunto, para que os dois coexistam ao mesmo tempo, todas as vezes que tentei deu erros e acabei me perdendo e voltei o código para o início, um conjunto apenas, até onde eu tinha conseguido. Eu não tive aula do assunto ainda e consegui fazer essa parte com tutoriais, mas não vi nenhum exemplo com duas listas. O que preciso é saber como criar o COnjunto 2 e repetir as mesmas funções que coloquei no COnjunto 1.

#include <stdio.h>
#include <stdlib.h>

struct Elemento{
	int num;
	struct Elemento *prox;
}; 
typedef struct Elemento elemento;

int tam;

void inicia(elemento *CONJUNTO1);
int menu(void);
void opcao(elemento *CONJUNTO1, int op);
elemento *criaNo();
void insereFim(elemento *CONJUNTO1);
void insereInicio(elemento *CONJUNTO1);
void exibe(elemento *CONJUNTO1);
void libera(elemento *CONJUNTO1);
void insere (elemento *CONJUNTO1);
elemento *retiraInicio(elemento *CONJUNTO1);
elemento *retiraFim(elemento *CONJUNTO1);
elemento *retira(elemento *CONJUNTO1);


int main(void)
{
	elemento *CONJUNTO1 = (elemento *) malloc(sizeof(elemento));
	if(!CONJUNTO1){
		printf("Sem memoria disponivel!\n");
		exit(1);
	}else{
	inicia(CONJUNTO1);
	int opt;
	
	do{
		opt=menu();
		opcao(CONJUNTO1,opt);
	}while(opt);

	free(CONJUNTO1);
	return 0;
	}
}

void inicia(elemento *CONJUNTO1)
{
	CONJUNTO1->prox = NULL;
	tam=0;
}

int menu(void)
{
	int opt;
	
	printf("Escolha a opcao\n");
	printf("0. Sair\n");
	printf("1. Zerar Conjunto 1\n");
	printf("2. Exibir Conjunto 1\n");
	printf("3. Adicionar elemento no final\n");
	printf("4. Escolher de onde tirar\n");
	printf("Opcao: "); scanf("%d", &opt);
	
	return opt;
}

void opcao(elemento *CONJUNTO1, int op)
{
	elemento *tmp;
	switch(op){
		case 0:
			libera(CONJUNTO1);
			break;
			
		case 1:
			libera(CONJUNTO1);
			inicia(CONJUNTO1);
			break;
		
		case 2:
			exibe(CONJUNTO1);
			break;
		
				
		case 3:
			insereFim(CONJUNTO1);
			break;
			
				
		case 5:
			tmp= retira(CONJUNTO1);
			printf("Retirado: %3d\n\n", tmp->num);
			break;
		
		default:
			printf("Comando invalido\n\n");
	}
}

int vazia(elemento *CONJUNTO1)
{
	if(CONJUNTO1->prox == NULL)
		return 1;
	else
		return 0;
}

elemento *aloca()
{
	elemento *novo=(elemento *) malloc(sizeof(elemento));
	if(!novo){
		printf("Sem memoria disponivel!\n");
		exit(1);
	}else{
		printf("Novo elemento: "); scanf("%d", &novo->num);
		return novo;
	}
}


void insereFim(elemento *CONJUNTO1)
{
	elemento *novo=aloca();
	novo->prox = NULL;
	
	if(vazia(CONJUNTO1))
		CONJUNTO1->prox=novo;
	else{
		elemento *tmp = CONJUNTO1->prox;
		
		while(tmp->prox != NULL)
			tmp = tmp->prox;
		
		tmp->prox = novo;
	}
	tam++;
}

void exibe(elemento *CONJUNTO1)
{
		if(vazia(CONJUNTO1)){
		printf("Lista vazia!\n\n");
		return ;
	}
	
	elemento *tmp;
	tmp = CONJUNTO1->prox;
	printf("CONJUNTO 1:");
	while( tmp != NULL){
		printf("%5d", tmp->num);
		tmp = tmp->prox;
	}
	printf("\n        ");
	int count;
	for(count=0 ; count < tam ; count++)
		printf("  ^  ");
	printf("\nORDEM DOS ELEMENTOS:");
	for(count=0 ; count < tam ; count++)
		printf("%5d", count+1);
	
		
	printf("\n\n");
}

Entrar

Arquivado

listas simples/vetores para conjuntos numéricos

Recommended Posts

andrecavalcanti 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

_Isis_ 202

Compartilhar este post

Link para o post

Compartilhar em outros sites

andrecavalcanti 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

andrecavalcanti 0

Compartilhar este post

Link para o post

Compartilhar em outros sites

Fixar div até atingir uma certa altura

Ajuda com Extends e envio para o banco

PHP+Codeginiter - Orientação para Impressão

Este projeto é apoiado pelas empresas

Fóruns

Tempo Real

Informação importante