O documento descreve uma estrutura de árvore binária balanceada implementada em C com funções para inserção, remoção, busca, impressão e liberação da memória. A árvore é representada por uma estrutura No que contém ponteiros para os filhos esquerdo e direito e um campo de dados inteiro.

1. 1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <locale.h>
4
5 struct No
6 {
7 int numero;
8 struct No *esquerda;
9 struct No *direita;
10 };
11 typedef struct No No;
12
13 int n, tam;
14
15 int altura(No *pRaiz);
16 int maior(int a, int b);
17 int contarFolhas(No *pRaiz);
18 int contarNos(No *pRaiz);
19 void exibirPosOrdem(No *pRaiz);
20 void exibirPreOrdem(No *pRaiz);
21 void exibirEmOrdem(No *pRaiz);
22 void remover(No **pRaiz, int numero);
23 No *MenorEsquerda(No **no);
24 No *MaiorDireita(No **no);
25 void inserir(No **pRaiz, int numero);
26 void criarArvore(No **pRaiz);
27 int isInTree(No* pRaiz, int num);
28 No* libera(No* pRaiz);
29
30 int main()
31 {
32 tam=0;
33 setlocale(LC_ALL, "Portuguese");
34 No *ARVORE = (No *) malloc(sizeof(No));
35 if(!ARVORE)
36 {
37 printf("nSem memória disponível!n");
38 exit(1);
39 }
40 else
41 {
42 criarArvore(ARVORE);
43 int opt;
44
45 do
46 {
47 system("cls");
48 opt=menu();
49 opcao(ARVORE,opt);
50 getchar();
51 }
52 while(opt);
53 free(ARVORE);
54 return 0;
55 }
56 }
57
58 int menu(void)
59 {
60 int opt;
61
62 printf("nn============================================================n");
63 printf(" Escolha a opcaon");
64 printf(" 0. Sair n");
65 printf(" 1. Zerar Árvore n");
66 printf(" 2. Imprimir Arvore em Ordem n");
67 printf(" 3. Imprimir Arvore em Pós-Ordem n");
68 printf(" 4. Imprimir Arvore em Pré-Ordem n");
69 printf(" 5. Inserir nó na Árvore n");
70 printf(" 6. Remover Nó da Árvore n");;
71 printf(" 7. Buscar um Nó na Árvore n");
72 printf(" 8. Atualizar um elemento de um NÓ da Árvore n");
73 printf(" 9. Encontrar o MAIOR elemento à direita da Árvore.n");
74 printf(" 10. Encontrar o MENOR elemento à esquerda da Árvore.n");
75 printf(" 11. Encontrar o MAIOR elemento da Árvore.n");
76 printf(" 12. Quantidade de NÓS da Árvore.n");
77 printf(" 13. Quantidade de NÓS FOLHAS da Árvore.n");
78 printf(" 14. Altura da Árvore.n");
79 printf(" 15. Verificar se pertence à Árvore.n");
80 printf("nnDigite a sua opcao: ");
81 scanf("%d", &opt);
82 printf("nn");
83
84 return opt;

2. 85 }
86
87 void opcao(No *ARVORE, int op)
88 {
89 No *tmp;
90 switch(op)
91 {
92 case 0:
93 libera(ARVORE);
94 printf("nÁrvore liberada com sucesso. Aperte qualquer tecla para sair!");
95 getchar();
96 break;
97
98 case 1:
99 libera(ARVORE);
100 criarArvore(ARVORE);
101 printf("Árvore Criada com Sucesso!");
102 getchar();
103 break;
104
105 case 2:
106 exibirEmOrdem(ARVORE);
107 getchar();
108 break;
109
110 case 3:
111 exibirPreOrdem(ARVORE);
112 getchar();
113 break;
114
115 case 4:
116 exibirPosOrdem(ARVORE);
117 getchar();
118 break;
119
120 case 5:
121 printf("nDigite um valor inteiro: ");
122 scanf("%d%*c",&n);
123 inserir(&ARVORE, n);
124 getchar();
125 break;
126
127 case 6:
128 if(vazia(ARVORE))
129 {
130 printf("nA árvore está vazia! ");
131 }
132 else
133 {
134 printf("nDigite um valor inteiro: ");
135 scanf("%d%*c",&n);
136 remover(&ARVORE,n);
137 }
138 getchar();
139 break;
140
141 case 7:
142
143 getchar();
144 break;
145
146 case 8:
147
148 getchar();
149 break;
150
151 case 9:
152 if(vazia(ARVORE))
153 {
154 printf("nA árvore está vazia! ");
155 }
156 else
157 {
158 printf("nMenor DIREITA: %d", MenorEsquerda(&ARVORE));
159 }
160 getchar();
161 break;
162
163 case 10:
164 if(vazia(ARVORE))
165 {
166 printf("nA árvore está vazia! ");
167 }
168 else

3. 169 {
170 printf("nMAIOR DIREITA: %d", MaiorDireita(&ARVORE));
171 }
172 getchar();
173 break;
174
175 case 11:
176 if(vazia(ARVORE))
177 {
178 printf("nA árvore está vazia! ");
179 }
180 else
181 {
182
183 }
184 getchar();
185 break;
186
187 case 12:
188 if(vazia(ARVORE))
189 {
190 printf("nA árvore está vazia! ");
191 }
192 else
193 {
194 printf("nQuantidade de Nós: %d", contarNos(ARVORE));
195 }
196 getchar();
197 break;
198
199 case 13:
200 if(vazia(ARVORE))
201 {
202 printf("nA árvore está vazia! ");
203 }
204 else
205 {
206 printf("nCONTAR FOLHAS: %d", contarFolhas(ARVORE));
207 }
208 getchar();
209 break;
210
211 case 14:
212 if(vazia(ARVORE))
213 {
214 printf("nA árvore está vazia! ");
215 }
216 else
217 {
218 printf("nALTURA DA ÁRVORE: %d", altura(ARVORE));
219 }
220 getchar();
221 break;
222
223 case 15:
224 if(vazia(ARVORE))
225 {
226 printf("nA árvore está vazia! ");
227 }
228 else
229 {
230 printf("nDigite um valor inteiro: ");
231 scanf("%d%*c",&n);
232 printf("nEstá na Árvore: %d", isInTree(&ARVORE,n));
233 }
234 getchar();
235 break;
236
237 default:
238 printf("nComando inválido! n");
239 }
240 }
241
242
243 int vazia(No *ARVORE)
244 {
245 return ARVORE==NULL;
246 }
247
248 void criarArvore(No **pRaiz)
249 {
250 *pRaiz = NULL;
251 }
252

4. 253
254 void inserir(No **pRaiz, int numero)
255 {
256 if(*pRaiz == NULL)
257 {
258 *pRaiz = (No *) malloc(sizeof(No));
259 (*pRaiz)->esquerda = NULL;
260 (*pRaiz)->direita = NULL;
261 (*pRaiz)->numero = numero;
262 printf("nNó %d inserido na raíz com sucesso",(*pRaiz)->numero );
263 }
264 else
265 {
266 if(numero < (*pRaiz)->numero)
267 {
268 inserir(&(*pRaiz)->esquerda, numero);
269 printf("nNó %d inserido à esquerda com sucesso", (*pRaiz)->numero);
270 }
271 if(numero > (*pRaiz)->numero)
272 {
273 inserir(&(*pRaiz)->direita, numero);
274 printf("nNó %d inserido à direita com sucesso", (*pRaiz)->numero);
275 }
276 }
277 }
278
279 No *MaiorDireita(No **no)
280 {
281 if((*no)->direita != NULL)
282 return MaiorDireita(&(*no)->direita);
283 else
284 {
285 No *aux = *no;
286 if((*no)->esquerda != NULL) // se nao houver essa verificacao, esse nó vai perder todos
os seus filhos da esquerda!
287 *no = (*no)->esquerda;
288 else
289 *no = NULL;
290 return aux;
291 }
292 }
293
294 No *MenorEsquerda(No **no)
295 {
296 if((*no)->esquerda != NULL)
297 return MenorEsquerda(&(*no)->esquerda);
298 else
299 {
300 No *aux = *no;
301 if((*no)->direita != NULL) // se nao houver essa verificacao, esse nó vai perder todos
os seus filhos da direita!
302 *no = (*no)->direita;
303 else
304 *no = NULL;
305 return aux;
306 }
307 }
308
309 void remover(No **pRaiz, int numero)
310 {
311 if(*pRaiz == NULL) // esta verificacao serve para caso o numero nao exista na arvore.
312 {
313 printf("Numero nao existe na arvore!");
314 getch();
315 return;
316 }
317 if(numero < (*pRaiz)->numero)
318 remover(&(*pRaiz)->esquerda, numero);
319 else if(numero > (*pRaiz)->numero)
320 remover(&(*pRaiz)->direita, numero);
321 else // se nao eh menor nem maior, logo, eh o numero que estou procurando! :)
322 {
323 No *pAux = *pRaiz; // quem programar no Embarcadero vai ter que declarar o pAux no
inicio do void! :[
324 if (((*pRaiz)->esquerda == NULL) && ((*pRaiz)->direita == NULL)) // se nao
houver filhos...
325 {
326 free(pAux);
327 (*pRaiz) = NULL;
328 }
329 else // so tem o filho da direita
330 {
331 if ((*pRaiz)->esquerda == NULL)
332 {

5. 333 (*pRaiz) = (*pRaiz)->direita;
334 pAux->direita = NULL;
335 free(pAux);
336 pAux = NULL;
337 }
338 else //so tem filho da esquerda
339 {
340 if ((*pRaiz)->direita == NULL)
341 {
342 (*pRaiz) = (*pRaiz)->esquerda;
343 pAux->esquerda = NULL;
344 free(pAux);
345 pAux = NULL;
346 }
347 else //Escolhi fazer o maior filho direito da subarvore esquerda.
348 {
349 pAux = MaiorDireita(&(*pRaiz)->esquerda); //se vc quiser usar o Menor da
esquerda, so o que mudaria seria isso:
350 pAux->esquerda = (*pRaiz)->esquerda; // pAux =
MenorEsquerda(&(*pRaiz)->direita);
351 pAux->direita = (*pRaiz)->direita;
352 (*pRaiz)->esquerda = (*pRaiz)->direita = NULL;
353 free((*pRaiz));
354 *pRaiz = pAux;
355 pAux = NULL;
356 }
357 }
358 }
359 }
360 }
361
362 void exibirEmOrdem(No *pRaiz)
363 {
364 if(pRaiz != NULL)
365 {
366 exibirEmOrdem(pRaiz->esquerda);
367 printf("%d | ", pRaiz->numero);
368 exibirEmOrdem(pRaiz->direita);
369 }
370 }
371
372 void exibirPreOrdem(No *pRaiz)
373 {
374 if(pRaiz != NULL)
375 {
376 printf("%d | ", pRaiz->numero);
377 exibirPreOrdem(pRaiz->esquerda);
378 exibirPreOrdem(pRaiz->direita);
379 }
380 }
381
382 void exibirPosOrdem(No *pRaiz)
383 {
384 if(pRaiz != NULL)
385 {
386 exibirPosOrdem(pRaiz->esquerda);
387 exibirPosOrdem(pRaiz->direita);
388 printf("%d | ", pRaiz->numero);
389 }
390 }
391
392 int contarNos(No *pRaiz)
393 {
394 if(pRaiz == NULL)
395 return 0;
396 else
397 return 1 + contarNos(pRaiz->esquerda) + contarNos(pRaiz->direita);
398 }
399
400 int contarFolhas(No *pRaiz)
401 {
402 if(pRaiz == NULL)
403 return 0;
404 if(pRaiz->esquerda == NULL && pRaiz->direita == NULL)
405 return 1;
406 return contarFolhas(pRaiz->esquerda) + contarFolhas(pRaiz->direita);
407 }
408
409 int maior(int a, int b)
410 {
411 if(a > b)
412 return a;
413 else
414 return b;

6. 415 }//maior
416
417
418 int altura(No *pRaiz)
419 {
420 if((pRaiz == NULL) || (pRaiz->esquerda == NULL && pRaiz->direita == NULL))
421 return 0;
422 else
423 return 1 + maior(altura(pRaiz->esquerda), altura(pRaiz->direita));
424 }
425
426 /* Função que verifica se um elemento pertence ou não à árvore */
427 int isInTree(No* pRaiz, int num)
428 {
429 if(vazia(&pRaiz)) /* Se a árvore estiver vazia, então retorna 0 */
430 {
431 return 0;
432 }
433
434 /* O operador lógico || interrompe a busca quando o elemento for encontrado */
435 return pRaiz->numero==num || isInTree(pRaiz->esquerda, num) || isInTree(pRaiz->direita, num);
436 }
437
438 No* libera(No* pRaiz)
439 {
440 if (!vazia(&pRaiz))
441 {
442 libera(pRaiz->esquerda); /* libera sae */
443 libera(pRaiz->direita); /* libera sad */
444 free(pRaiz); /* libera raiz */
445 }
446 return NULL;
447 }
448