Esempio n. 1
0
Tree* adicionaItemArvore(Tree* arvore, void* dados, FCompara comparador)
{
Tree * folha;
int i=0;
	
for(;;){	
i=comparador(dados,arvore->dados);
		if(i==0) return;		
		if(i<0){
		if(arvore->esq==NULL){		
			folha=criaArvore(dados);
			arvore->esq=folha;
			folha->pai=arvore;
			return;		
		}
		else
		arvore=arvore->esq;
			
	}
	if(i>0){
		if(arvore->dir==NULL){
		folha=criaArvore(dados);
		arvore->dir=folha;
		folha->pai=arvore;
		return;		
		}
		else
		arvore=arvore->dir;		
		
		
	}
}
}
Esempio n. 2
0
//Constrói a Árvore Binária com base nas leituras pré-ordem e in-ordem.
ArvoreBinaria montaArvore(char* notacao_in, char* notacao_pre, int numero_nos) {
	char raiz;
	//Obtem a raiz com base na posição atual da leitura em pre-ordem
	raiz = notacao_pre[0];

	//Caso base: Caso haja somente um nó, o mesmo é uma folha e obrigatoriamente não possui subarvores esquerda ou direita.
	if (numero_nos == 1) {
		return criaArvore(raiz, NULL, NULL);
	}
	else {
		//Encontra o tamanho das sub-arvores com base na propriedade da leitura em inordem.
		int indice_raiz;
		for(indice_raiz = 0; (indice_raiz < numero_nos) && (notacao_in[indice_raiz] != raiz); indice_raiz++) {
		}

		//Caso possua uma subarvore à esquerda da raiz, a mesma é encontrada recursivamente.
		ArvoreBinaria subarvore_esquerda = NULL;
		if(indice_raiz > 0) {
			subarvore_esquerda = montaArvore(notacao_in, notacao_pre+1, indice_raiz);
		}

		//Caso possua uma subarvore à direita da raiz, a mesma é encontrada recursivamente.
		ArvoreBinaria subarvore_direita = NULL;
		if(indice_raiz < numero_nos - 1) {
		subarvore_direita = montaArvore((notacao_in + indice_raiz + 1), (notacao_pre + indice_raiz + 1), (numero_nos - indice_raiz - 1));
		}

		//"Acopla" as subarvores esquerda e direita com base nas chamadas recursivas.
		return criaArvore(raiz, subarvore_esquerda, subarvore_direita);
	}
}
Esempio n. 3
0
int main(){

	arvore* a = criaArvore();

	adicionaElem(&(a->raiz), 10, a);
	adicionaElem(&(a->raiz), 3, a);
	adicionaElem(&(a->raiz), 8, a);
	adicionaElem(&(a->raiz), 5, a);
	adicionaElem(&(a->raiz), 6, a);
	adicionaElem(&(a->raiz), 4, a);
	adicionaElem(&(a->raiz), 9, a);
	adicionaElem(&(a->raiz), 2, a);
	adicionaElem(&(a->raiz), 1, a);
	adicionaElem(&(a->raiz), 11, a);
	imprimeArv(a->raiz);
	printf("-----------------------\n");

	noAvo = NULL;
	noPai = NULL;
	removeElem(&(a->raiz), 8, a);
	printf("Raiz: %d\n", a->raiz->elem);
	imprimeArv(a->raiz);
	printf("-----------------------\n");
	return 0;

}
Esempio n. 4
0
int main()
{
    struct Arvore *t = criaArvore();
    int num;
    char c[5];

    gets(c);

    while(scanf("%d", &num) != EOF)
        inserir(t, criaNo(&num));

    if(strcmp(c, "POS") == 0)
        posOrdem(t->raiz);

    else if(strcmp(c, "PRE") == 0)
        preOrdem(t->raiz);

    else
        inOrdem(t->raiz);

    printf("%d", altura(t->raiz));
    
    printf(" %d", rotacao);
    
}
Esempio n. 5
0
int main() {
    FILE *arq;
    char nomeArquivo[30];
    int dado;

    printf("Digite o nome do arquivo de entrada [nao eh necessario '.txt']: ");
    scanf("%s", &nomeArquivo);
    strcat(nomeArquivo, ".txt");

    arvore *A = criaArvore();
    arq = fopen(nomeArquivo, "r");
    if (arq == NULL) {
        printf("Erro ao abrir o arquivo %s", nomeArquivo);
        return 0;
    }

    while (fscanf(arq, "%d", &dado) != EOF) {
        if (ferror(arq)) {
            printf("Erro ao ler arquivo de dados");
            return 0;
        }
        insereno(A, dado);
    }
    printf("\n");
    printf("   Valor\tCor [V = Vermelha e P = Preta]\n\n");
    percorreOrdem(A->dir);
    printf("\n");

}
Esempio n. 6
0
int main(){
  int opcao, chave, dado, tamanho, i;
  struct arvore *raiz = criaArvore(); // cria uma arvore com nenhum dado
  
  printf("Forneca o numero de chaves que deseja adicionar\n");
  scanf("%d", &tamanho);
  for(i = 0 ; i<tamanho ; i++){
      printf("\nForneca a chave do %do elemento\n", i+1);
      scanf("%d", &chave);
      insercao(&raiz, chave);
  }  
  printf("\n\n");
  
  menu(); // Cria o menu para o usuario escolher a opcao
  scanf("%d", &opcao);

  while (opcao >= 1 && opcao <= 5){
      switch(opcao){
          case 1: 
               printf("\nForneca o numero de chaves que deseja adicionar\n");
               scanf("%d", &tamanho);
               for(i = 0 ; i<tamanho ; i++){
                   printf("\nForneca a chave do %do elemento\n", i+1);
                   scanf("%d", &chave);
                   insercao(&raiz, chave);
               }  
               printf("\n\n");
               break;
          case 2: 
               printf("\nForneca a chave a ser removido\n");
               scanf("%d", &chave);
               remocao(raiz, chave);  
               printf("\n\n");
               break;
          case 3: 
               printf("\nForneca a chave que deseja buscar\n");
               scanf("%d", &chave);
               busca(raiz, chave);
               printf("\n\n");
               break;
          case 4: 
               printf("\nImpressao\n");
               impressao(raiz);
               printf("\n\n");
               break;
          case 5: 
               printf("\nImpressao em Labelled Bracketing \n");
               impressaoLabelledBracketing(raiz);
               printf("\n\n");
               break;
      }
      
      menu();
      scanf("%d", &opcao);
  }
  return 0;
  system("PAUSE");	
}
Esempio n. 7
0
int main(){
	Arvore* minhaArvore;
	minhaArvore = criaArvore();
    popular(minhaArvore);
    exibeOrdem(minhaArvore);
    exibeBusca(minhaArvore);
    //exibeRemocao(minhaArvore);
    //exibeOrdem(minhaArvore);
 
	return 1;
}
Esempio n. 8
0
int main () {
    TLista *head;
    int i;

    criaArvore(&head);
    for (i = 0; i < 10; i++) {
        insere (&head, i);
    }
    for (i = -10; i < 0; i++) {
        insere (&head, i);
    }

    printf ("Fim da insercao\n");
}
Esempio n. 9
0
//Hash* criaHash()
void insereNaHash(Hash* h, Elemento* x, int type){
  int index = x->matricula % h->tam;
  if(type == 0){
    if(h->hash[index] == NULL){
      h->hash[index] = criaArvore(x);
    }
    else insereElemento(h->hash[index], x);
  }
  if(type == 1){
    if(h->hashSBB == NULL){
      fprintf(stderr, "h->hashSBB is null\n");
    }
    if(h->hashSBB[index] == NULL) {
      h->hashSBB[index] = criaArvoreSBB(x);
    } else insereSBB(&(h->hashSBB[index]), x);
  }
}
Esempio n. 10
0
/* Programa principal */
int main(){
	Arvore* minhaArvore;
	minhaArvore = criaArvore(); 
       
    popular(minhaArvore);
    
    printf("\n\nBuscando valores da árvore \n");
    imprimeBusca(buscarVerificarNulidade(minhaArvore, 10));
    imprimeBusca(buscarVerificarNulidade(minhaArvore, 20));
    imprimeBusca(buscarVerificarNulidade(minhaArvore, 15));
    imprimeBusca(buscarVerificarNulidade(minhaArvore, 31));
    
    printf("\n\nÁrvore pré-ordem:\n");
    imprimeArvorePreOrdem(minhaArvore);
    
	return 1;
}
Esempio n. 11
0
void adicionaItemArvore( Tree* arvore, void* dados, FCompara comparador) {
Tree *folha;
int i;
i=comparador(arvore->dados, dados);

	while(arvore!=NULL){
	if(i==0) return;	
	if(i < 0) { //vai pra esquerda
		folha=arvore->esq;
	}
	 if(i>0) { //vai pra direita
		folha=arvore->dir;
	}
	}

folha=criaArvore(dados);
if(i<0) arvore->esq=folha;
else arvore->dir=folha;
}
Esempio n. 12
0
//insere um Elemento na Hash
void insereNaHash(Hash* h, Elemento* x, int boolSBB){

	int pos = funcaoHash(x, h);

	if (boolSBB==1){
		if (h->hashSBB[pos]==NULL){
				h->hashSBB[pos] = criaArvoreSBB(x);
		} else{
			insereElementoSBB(&(h->hashSBB[pos]), x);
		}
		h->nElem++;
	}else{
		if (h->hash[pos]==NULL){
			h->hash[pos] = criaArvore(x);
		} else{
			insereElemento(h->hash[pos], x);
		}
		h->nElem++;
	}
}
Esempio n. 13
0
int main() {
  Tree * arvore;
  FILE * f;
 
  arvore = criaArvore(VALOR2);
  adicionaItemArvore(arvore, VALOR1, compara_palavras);
  adicionaItemArvore(arvore, VALOR3, compara_palavras);
  adicionaItemArvore(arvore, "palavra4",compara_palavras);
  adicionaItemArvore(arvore, "palavra",compara_palavras);
  adicionaItemArvore(arvore, "oi",compara_palavras); 
  // mostra a arvore, para se ter uma ideia de sua estrutura
  mostraArvore(arvore, conversor_string);
 
  // grava a arvoreno arquivo "arvore.txt"
  f = fopen("arvore.txt", "w");
  gravaArvore(arvore,conversor_string,f);
  fclose(f);
 
  return 0;
}
Esempio n. 14
0
Tree * carregaArvore(FILE * f, FParser leitor){
	Tree* raiz;
	char buffer[1024];

	fgets(buffer, 1023,f);
	
	if(!feof(f)) {
		buffer[strlen(buffer)-1]=0; //remove o /n final
		if(buffer[0]==0) return NULL;
		

//se consegue ler mas nao chegou ao fim do arquivo
		raiz=criaArvore(leitor(buffer));


		raiz->esq=carregaArvore(f, leitor);
			if(raiz->esq!=NULL) raiz->esq->pai=raiz;

		raiz->dir=carregaArvore(f,leitor);
			if(raiz->dir!=NULL) raiz->dir->pai=raiz;
}
return raiz;
}
Esempio n. 15
0
int main(int argc, char ** argv) {
  FILE * f;
  char palavra[16];
  Tree * arvore = NULL;
  int n = 0;
 
  // O nome do arquivo deve ser informado na linha de comando
  if (argc < 2) {
    printf("Uso: %s arquivo_de_palavras\n", argv[0]);
    return 0;
  }
 
  // Se não conseguir abrir o arquivo, termina o programa
  if ((f = fopen(argv[1], "r+")) == NULL) {
    perror("Ao abrir o arquivo");
    return errno;
  }
 
  // Enquanto não chegar ao fim do arquivo ...
  while (!feof(f)) {
    // Lê uma palavra composta pelos caracteres contidos na macro PALAVRA
    if (fscanf(f, PALAVRA, palavra) > 0) {
      if (! arvore) arvore = criaArvore(strdup(palavra));
      else adicionaItemArvore(arvore, strdup(palavra), compara_palavras);
    } else {
      // Se não conseguir ler uma palavra,
      // pula todos os caracteres que não aparecem em palavras (espaços e pontuação)
      // A macro PULAR contém todos os caracteres que não estão em PALAVRA.
      fscanf(f, PULAR);
    }
  }
 
  printf("Criou a árvore\n");
 
  // rebobina o arquivo
  rewind(f);
 
  // contador de palavras nao encontradas na arvore
  n = 0;
  while (!feof(f)) {
    // Lê uma palavra composta pelos caracteres contidos na macro PALAVRA
    if (fscanf(f, PALAVRA, palavra) > 0) {
      if (!obtemItemArvore(arvore, palavra, compara_palavras)) n++;
    } else {
      // Se não conseguir ler uma palavra,
      // pula todos os caracteres que não aparecem em palavras (espaços e pontuação)
      // A macro PULAR contém todos os caracteres que não estão em PALAVRA.
      fscanf(f, PULAR);
    }
  }
 
  printf("Consultou todas as palavras (%d omissas)\n", n);
  char pal[30];
  int i;
  for(;;){
	printf("Qual a palavra que deseja verificar\n");
	scanf("%s", pal);
	if(obtemItemArvore(arvore, pal, compara_palavras)==NULL){
		 printf ("A palavra é desconhecida; Deseja adicioná-la? 1-sim, 2-não\n");
		 scanf ("%d", &i);
		 if(i==1) {
		 	adicionaItemArvore(arvore, pal, compara_palavras);
			fprintf(f,"%s\n",pal);
			printf("A palavra foi adicionada\n");
			fclose(f);
			return;
			}
	}
	
	else printf ("A palavra é conhecida\n");
  }	
 
  // fecha o arquivo e termina o programa
  fclose(f);
 
  return 0;
}
Esempio n. 16
0
int main(int argc, char ** argv) {
  FILE * f,*f2;
  char palavra[16];
  Tree * arvore = NULL;
  int n = 0,fc=0;
 
  // O nome do arquivo deve ser informado na linha de comando
  if (argc < 2) {
    printf("Uso: %s arquivo_de_palavras\n", argv[0]);
    return 0;
  }
 
  // Se não conseguir abrir o arquivo, termina o programa
  if ((f = fopen(argv[1], "r+")) == NULL) {
    perror("Ao abrir o arquivo");
    return errno;
  }
 
  // Enquanto não chegar ao fim do arquivo ...
  while (!feof(f)) {
    // Lê uma palavra composta pelos caracteres contidos na macro PALAVRA
    if (fscanf(f, PALAVRA, palavra) > 0) {
      if (! arvore) arvore = criaArvore(strdup(palavra));
      else{ 
        adicionaItemArvore(arvore, strdup(palavra), compara_palavras);
	fc++;
	if(fc>1000){
	  arvore=balanceiaArvore(arvore);
	  fc=0;	
	}	   
      } 
    } else {
      // Se não conseguir ler uma palavra,
      // pula todos os caracteres que não aparecem em palavras (espaços e pontuação)
      // A macro PULAR contém todos os caracteres que não estão em PALAVRA.
      fscanf(f, PULAR);
    }
  }
 
  printf("Criou a árvore com altura %d\n", altura(arvore));
 
  // rebobina o arquivo
  rewind(f);
 
  // contador de palavras nao encontradas na arvore
  n = 0;
  while (!feof(f)) {
    // Lê uma palavra composta pelos caracteres contidos na macro PALAVRA
    if (fscanf(f, PALAVRA, palavra) > 0) {
      if (!obtemItemArvore(arvore, palavra, compara_palavras)) n++;
    } else {
      // Se não conseguir ler uma palavra,
      // pula todos os caracteres que não aparecem em palavras (espaços e pontuação)
      // A macro PULAR contém todos os caracteres que não estão em PALAVRA.
      fscanf(f, PULAR);
    }
  }
 
  printf("Consultou todas as palavras (%d omissas)\n", n);
 
char pal[16];
int i,result;

for(;;){
		printf("\nEscreva a palavra a ser verificada!\n(Para sair do programa digite:0)\n");
		scanf("%s",pal);
		if(strcmp("0",pal)==0){
			fclose(f);
			if ((f2 = fopen("arvore.txt", "w")) == NULL){
    				perror("Ao abrir o arquivo");
    				return errno;
 			 }
  			gravaArvore(arvore,mostra_palavras,f2);
  			fclose(f2);
			return;
		}			
		if(obtemItemArvore(arvore,pal,compara_palavras)!=NULL){
			printf("A palavra existe");
		}
		else{
			printf("\nA palavra não existe no dicionário, quer acrescentala?\nSim=1\nNão=0\n");
			scanf("%d",&i);
				if(i){
					adicionaItemArvore(arvore, strdup(pal), compara_palavras);	
					fprintf(f,"%s\n",pal);
				}	
		}	
	}

  // fecha o arquivo e termina o programa
  fclose(f);
 
 
  return 0;
}