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;
}
}
}
//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);
}
}
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;
}
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);
}
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");
}
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");
}
int main(){
Arvore* minhaArvore;
minhaArvore = criaArvore();
popular(minhaArvore);
exibeOrdem(minhaArvore);
exibeBusca(minhaArvore);
//exibeRemocao(minhaArvore);
//exibeOrdem(minhaArvore);
return 1;
}
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");
}
//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);
}
}
/* 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;
}
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;
}
//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++;
}
}
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;
}
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;
}
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;
}
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;
}