Nome: Renê Paiva ID: 74151

Estrutura de Dados II

Árvore Binária

Inserir Elemento na árvore binária:

void inserir(tArv *t, int dado){

1. int ok;
2.
3. // se t aponta para null, a inserção é na raiz...
4.
5. if (*t == NULL) {
6. *t = (tnoarv *) malloc(sizeof(tnoarv));
7.
8. if (*t == NULL) return;
9. (*t)->esq = NULL;
10. (*t)->dir = NULL;
11. (*t)->info = dado;
12. }
13.
14. // Se o dado a ser inserido for menor que o nó atual, recursividade à esquerda
15.
16. if (dado < (*t)->info) {
17. inserir(&((*t)->esq), dado);
18. }
19. else{
20.
21. // Se o dado a ser inserido for menor que o nó atual, recursividade à direita
22.
23. if (dado > (*t)->info) {
24. inserir(&((*t)->dir), dado);
25. }
26. }

Remover elemento da árvore binária:

void remover(tArv *raiz, int valor){

1. tArv aux;
2. if(!arvore_vazia(*raiz)){
3.
4. // se o valor que será removido for menor que o nó atual,
5.
6. if(valor < (*raiz)->info){
7. remover(&((*raiz)->esq), valor); // faz recursividade á esquerda
8. }
9.
10. else{
11.
12. // se o valor que será removido for maior que o nó atual,
13.
14. if(valor > (*raiz)->info){
 15. remover(&((*raiz)->dir), valor); // faz recursividade á direita.
16. }
17. else{
18.
19. // encontrou
20.
21. // quando o nó a ser removido for encontrado,
22.
23. if( !arvore_vazia((*raiz)->esq) && !arvore_vazia((*raiz)->dir) ){
24.
25. // verificamos se os nós filhos da esquerda e direita não são null.
26.
27. // se não forem null, buscamos o menor nó a partir do nó da direita.
28.
29. aux = minimo((*raiz)->dir);
30. (*raiz)->info = (aux->info);
31. remover(&(*raiz)->dir, (*raiz)->info);
32. }
33. else{
34. // caso os nó da direita e da esqueda, ou somente o da direita for null,
35.
36. // precisamos apenas remover
37.
38. aux = *raiz;
39.
40. // o nó atual e fazer ajustar os ponteiros
41.
42. if(arvore_vazia((*raiz)->esq)){
43.
44. // se o nó da esquerda for vazio
45.
46. // o nó pai do atual, apontará para o filho da direita do nó atual.
47. *raiz = (*raiz)->dir;
48. }
49.
50. else {
51.
52. // se o nó da esquerda não for vazio.
53.
54. // o nó pai do atual, apontará para o filho da esquerda do nó atual.
55.
56. *raiz = (*raiz)->esq;
57. }
58. free(aux);
59. }
60. }
61. }
62. }
63. }

Retorna o nó com valor minímo:

1. tArv minimo(tArv T){

2.
3. // procura o nó com valor mínimo
4.
5. if(arvore_vazia(T)){
6.
7. return NULL; }
8.
9. else{
10.
11. if( arvore_vazia(T->esq) ){
12.
13. return T; }
 14. else{
15.
16. return minimo(T->esq);
17.
18. }
19. }
20. }

Retorna o nó com o valor máximo:

1. tArv maximo(tArv T){

2.
3. // procura o nó com valor máximo
4.
5. if( !arvore_vazia(T) ){
6.
7. while( !arvore_vazia(T->dir) ){
8. T = T->dir;
9. }
10. }
11.
12. return T;
13. }

Busca elemento na árvore binária:

1. //=======================================================================
2.
3. // A função pesquisa nos nós da árvore o valor passado como parâmetro,
4.
5. // caso o valor esteja na árvore, ela retorna este nó que está o valor.
6.
7. tArv busca_elemento(tArv t, int dado){
8.
9. tArv achou;
10.
11. if (arvore_vazia(t)) return NULL;
12.
13. if (t->info == dado) return t;
14. achou = busca_elemento(t->esq, dado);
15.
16. if (arvore_vazia(achou))
17. achou = busca_elemento(t->dir, dado);
18.
19. return achou;
20. }