Beispiel #1
0
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;
    }
Beispiel #2
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");
} 
Beispiel #3
0
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");
	}
	
}
Beispiel #4
0
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]);
}
Beispiel #6
0
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);
  }
} 
Beispiel #7
0
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++;
    }
}
Beispiel #10
0
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;
}
Beispiel #12
0
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);
		}
	}
}
Beispiel #13
0
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);
}
Beispiel #14
0
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);
	}
}
Beispiel #15
0
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;
	}
}
Beispiel #16
0
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);
}
Beispiel #17
0
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);
}
Beispiel #19
0
list New_share(list head, int ID){
    return Insere(head, ID);
}
Beispiel #20
0
void InsereAresta(int *V1, int *V2, TipoGrafo *Grafo){
  TipoItem x;
  x.Vertice = *V2;
  Insere(&x, &Grafo->Adj[*V1]);
}
Beispiel #21
0
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);
}
Beispiel #23
0
void Push (int ID){
    stack_S = Insere(stack_S, ID);
}
Beispiel #24
0
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;
} 
Beispiel #25
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);
}