Método GetNode()

Esse método tem como objetivo retornar ao usuário o peso de nó escolhido. Para isso é necessário passar como parâmetro ao método o índice do nó desejado.
Por padrão, quando não tiver sido inserido um valor de peso ao nó o valor retornado será 0.

4: Verifica se o índice passado por parâmetro é menor do que o número total de nós.
5: Caso o valor do índice seja menor que a quantidade de nós então o valor do peso do nó desejado será retornado ao usuário.7: Caso o valor do índice seja maior que a quantidade total de nós então uma mensagem é enviada ao usuário falando que a posição solicitada é inválida.

Método SetPesoNode()

Esse método tem o objetivo de inserir valores de peso para os nós do grafo.
Esse método tem duas variações na forma de passar parâmetro.
A primeira, pede como parâmetro o índice do nó e o valor do peso desejado, já a segunda forma pede somente o índice do nó.
As duas formas serão apresentadas a seguir, começando pelo método que passa os dois parâmetros e em seguida pelo método que só pede o índice do nó.

4: Verifica se o índice passado por parâmetro é menor do que o número total de nós.
5: Caso o valor do índice seja menor que a quantidade de nós então o valor do peso passado por parâmetro é adicionado na array de Peso dos Nós no índice correspondente ao nó desejado pelo usuário.
7: Caso o valor do índice seja maior que a quantidade total de nós então uma mensagem é enviada ao usuário falando que a posição solicitada é inválida.

5: Chama o método SetPesoNode que tem dois parâmetros, passando o índice do nó que foi recebido como parâmetro e o valor 1 para o peso do nó.
Esse valor foi padronizado para quando um valor de nó não é passado por parâmetro.

Método GetAresta()

Esse método tem como objetivo retornar ao usuário o peso de uma aresta escolhida. Para isso é necessário passar como parâmetro ao método o nó de partida e de destino da aresta desejada.
Por padrão, quando a aresta dos dois pontos passados por um usuário não existir o valor retornado será 0.



4: Verifica se os nós de origem ou de destino são menores que a quantidade total de nós do grafo.
5: Caso os nós de origem e de destino sejam menores então o método retorna a matriz na posição de origem e destino para o usuário. O valor guardado na matriz é o peso da aresta em questão.
7: Caso o nó de origem ou de destino for maior que a quantidade total de Nós então uma mensagem é enviada ao usuário falando que a posição solicitada é inválida.

Método ShowMemory()

Esse método tem a finalidade de calcular e imprimir a quantidade de memória gastapela classe de grafos quando utiliza a tecnica de matrizes de adjacência e delistas de adjacências.Julgo que o calculo de memória utilizada para matrizes seja mais simples do quelistas, portanto é por ela (Matriz adjacênte) que começaremos.
Bom, na matriz guardamos valores inteiros que ocupa 4Bytes de espaço de memória.Se já sabemos quanto cada espaço alocado de memória tem separadamente, entãoprecisamos descobrir quantos espaços reservamos para contruir a matriz.
Mas como descobrir isso?
Isso é simples, pois o usuário entra com a quantidade de nós que ele deseja, e amatriz adjacênte, é uma matriz quadrada do valor total de nós, ou seja tem aquantidade de nós de linha e coluna.Por exemplo:
O usuário diz que o objeto de grafos instanciado por ele terá cinco nóslogo nossa matriz tem cinco linhas e cinco colunas.
Sendo assim, elevamos a quantidade de nós ao quadrado para saber a quantidade deíndices da matriz. Após isso pegamos o resultado adquirido e multiplicamos por 4que é a quantidade de bytes ocupados por uma variável do tipo inteiro.

4: Múltipicla 4 (valor de Bytes reservados da memória para uma variável do tipo inteiro) pela quantidades de nós do grafo elevado ao quadrado.

5-8: Impressão da informação calculada.

Método SetAresta()

Esse método tem como objetivo criar a aresta entre dois pontos que são definidos pelo usuário via parâmetros.
Nesse método conseguimos incluir também o valor de peso da aresta e dizer se ela é uma aresta dirigida ou não.
Existem três variações de possibilidade de entrada de parâmetros nesse método. A imagem mostrada a baixo é o método com quantidade máxima de parâmetros que se pode passar.
As outras duas variações serão mostradas logo após a explicação de cada linha do método.

Vale ressaltar que, se o valor do parâmetro de direção for 0, então a aresta é não dirigida e se o valor do parâmetro for 1 então a aresta é dirigida.






58: Condição para verificar se os parâmetros passados pelo usuário de nó de origem e nó de destino são valores menores que o tamanho do atributo Nos.
Essa verificação tem de ser feita, porque se, por exemplo, tentarmos acessar o índice 5 de um vetor que só tem 3 posições o programa irá dar erro por tentar acessar um índice que não existe.
60: Caso os valores dos pontos de inicio e fim forem menor que o atributo Nos, então é verificado se o parâmetro direcao (que verifica se a aresta é ou não dirigida) recebeu o valor 0 ou 1.
61: Caso a condição for verdadeira então a Matriz recebe o peso da aresta passado por parâmetro na posição (também passada por parâmetro) do ptoOrigem e ptoDestino.
62: Caso a condição da linha 11 for falsa então é verificado se o valor passado por parâmetro para direção é igual a 0
64-65: Se essa condição for verdadeira então a Matriz recebe o peso nos dois sentidos.

Agora muitos devem estar se perguntando o que é esses dois sentidos mencionados acima.
Bom, vamos tentar explicar:
Vamos supor que uma aresta de peso 5 irá ser criada. É passado como parâmetro também o ponto inicial (definido pelo parâmetro ptoOrigem) 7 e ponto de destino (definido pelo parâmetro ptoDestino) 10.
Se o grafo não for dirigido (direcao = 0) então o grafo não tem direção, ou seja, não tem ponto inicial ou final.
Sendo assim, o ponto definido como ponto de origem é na verdade o ponto inicial e também o final, ou seja, essa aresta pode ir do ponto 7 até 10 ou do ponto 10 até 7.


67: Caso as condições das linhas 60 e 62 forem falsas então uma mensagem de erro é enviada ao usuário.


Agora serão mostradas as outras formas de chamar o método SetAresta que só varia pelo número de parâmetros passados.





No primeiro método que vai da linha 78 até a linha 81 o parâmetro de peso da aresta não é passado, portanto, por padronização chamamos o método apresentado anteriormente do SetAresta passando o valor do peso como 1.

Já no segundo método apresentado que vai da linha 85 até a linha 88, os valores de peso da aresta e direcao não são setados. Portanto, por padronização passamos os valores, tanto de peso, quanto de direção da aresta, valendo 1.

Método GerarGrafo()

Esse método tem por objetivo dimensionar os valores para o grafo que será gerado.
Esse método recebe o tamanho passado como parâmetro e a partir disso gera o vetor de peso dos nós, a matriz de adjacência.
Vale ressaltar que esse método não é acessível aos usuários.
O usuário, quando instancia o objeto grafo, passa o valor do tamanho o grafo e então o construtor do objeto chama essa função para realizar todos os dimensionamentos.



36: Condição que verifica se o tamanho passado como parâmetro para o método é maior que zero.
38: Se o valor de tam for maior que zero então o atributo Nos receberá o valor passado por parâmetro.
39: É criado o vetor para peso de acordo com o tamanho do grafo passado por parâmetro.
40: É criado o vetor inicial da matriz de acordo com o tamanho passado por parâmetro.

Tanto no caso da Matriz quanto o Peso, o tamanho passado por parâmetro refere-se à quantidade de posições que eles terão.
Por exemplo, se o tamanho passado for 3, então peso será um vetor com três posições (vai de 0 a 2).
No caso da matriz esse primeiro vetor serve como um local onde guarda o endereço de memória das linhas que serão guardados os registros.
42-43: Laço que cria a quantidade de linhas da matriz de acordo com o valor entrado.
47-49: Se a condição da linha 3 for falsa então os atributos Nos, Peso e Matriz receberão NULL como valor.

Classe de Grafos

Inicialmente apresentaremos a estrutura que a classe grafo está tomando nesse começo de desenvolvimento.
Por problemas de entendimento de como a classe seria desenvolvida, tivemos de mudar muitas coisas nela, mas agora ela está corrigida.

Abaixo serão apresentados os atributos iniciais da classe e os protótipos dos métodos criados até então.





8: Private (Área Privada) - Todos os métodos, variáveis e objetos que são criados nessa área só podem ser acessados, ou ter seus valores alterados dentro da própria classe.
9: Declaração do atributo que define a quantidade de nós que o grafo irá ter.
10: Declaração do atributo (em forma de vetor) que define o peso dos nós.
11: Declaração do atributo (em forma de matriz) que define as arestas do grafo.
13: Protótipo do método GerarGrafo.
14: Public (Área Pública) - Todos os métodos, variáveis e objetos que são criados nessa área podem ser acessados, ou ter seus valores alterados de qualquer outra classe que faça referência a essa.
15: Construtor da classe onde não é necessário que passe parâmetro.
17: Chama o método GerarGrafo, passando o valor 0 como parâmetro. No próximo post esse método (e outros) serão explicados.
19: Construtor da classe onde o usuário entra com o valor de parâmetro.
21: Chama o método GerarGrafo, passando o valor que o usuário passou como parâmetro. No próximo post esse método (e outros) serão explicados.
24-30: Protótipo dos métodos da classe.

GRAFOS

Consideramos informalmente, grafo como um conjunto não vazio de pontos V (vértices, nós, nodos) podendo ou não haver ligações entre eles através de linhas (arcos, arestas). A cada aresta do grafo podemos associar um par de nós do grafo.


Alguns exemplos de aplicações dos grafos:
1. Modelagem de circuitos digitais
2. Representação de processos em sistemas paralelos ou distribuídos.
3. Simulação e avaliação de desempenho

· Um grafo G é constituído por um conjunto N de elementos e por uma relação binária A entre estes elementos.

Escreve-se: G = (N, A).
· N são denominados nós (ou vértices).
· A são denominados arcos (ou arestas).

Ex:

N={1, 2, 3, 4}
A={(1, 2), (1, 4), (2, 1), (3, 1), (3, 2), (3, 4), (4, 2)}

· Nós ligados por arcos são ditos adjacentes (do ex. 3 é adjacente de 1, 2 e 4).
· Arcos são incidentes de um nó (partem dele) ou incidentes a um nó (chegam nele)
- incidentes do nó 2 – (partem dele) - (2, 1), (3, 2) e (3, 4)
- incidente no nó 1 - (1, 2)
· O grau de um nó é igual ao número de arcos que incidem a ele.
· Um caminho é a seqüência de arcos e nós percorridos com o objetivo de ligar dois nós não adjacentes.
(Ex: (1,2) e (2,3) é o caminho que liga o nó 1 ao nó 3. )
· Um circuito é um caminho que pode ser percorrido infinitamente dentro do grafo. Ex: (1,2), (2,4), (4,1); ou (3,3).
· Ramo Incidente num vértice v, é qualquer ramo para o qual v é vértice destino. No caso de ramo não orientado é incidente nos dois vértices que o ramo liga.
· Anel é um ramo de um grafo que liga um vértice a si próprio
· Ramos Paralelos são ramos que ligam os mesmos nós
· Multigrafo é um grafo que contem ramos paralelos, caso contrário será Grafo Simples
· Multiplicidade (peso) de um ramo valor que indica o número de ramos, com o mesmo sentido, que ligam 2 nós. Pode generalizar-se este conceito de peso e associar-se a cada ramo um valor inteiro que representará um atributo do ramo. Por exemplo, no caso de representação de um mapa das rua de uma cidade, poder-se-ia considerar em cada ramo um número (peso) que poderia ser a densidade de tráfego.
· Vértice Isolado é um vértice que não é origem nem destino de nenhum ramo.
Grafo Nulo é um grafo constituído só por vértices isolados.
· Um grafo conexo é aquele que possui um nó a partir do qual existem caminhos para todos os demais nós.
· Um subgrafo é aquele onde é considerado apenas um subconjunto dos nós do grafo original.
· Um grafo parcial, considera-se um subconjunto dos arcos do grafo original, permanecendo todos os nós.Ex:

· Um grafo é acíclico quando não possui circuitos.

· Uma rede é um tipo especial de grafo que possui um nó fonte, a partir do qual todos os demais nós são atingidos e um nó sorvedouro, do qual não parte nenhum nó.

· Os grafos vistos até agora são dígrafos, ou grafos dirigidos, nos quais a relação binária não é simétrica, ou seja, não implica em retorno.

· Grafos valorados (weighted graphs): Um número pode ser associado aos nós ou arcos de um grafo (dirigido ou não).

Ex:

· Existem maneiras diferentes dese representar um grafo, como por exemplo, matrizes de adjacência e listas de adjacência

MATRIZ DE ADJACÊNCIA

- Usar uma matriz para representar um grafo permite:obter caminhos, ciclos e outras características dos grafos.
- Preferível em grafos pequenos.
- Requer apenas um bit por entrada.

Este grafo é representado por uma matriz quadrada M (n x n) cujos elementos são mij em que:
- As linhas correspondem aos vértices origem e as colunas aos vértices destino.

- mij=1 se (vi,vj) Î E (existe ligação entre i e j)

- mij=0 não existe ligação entre i e j.

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Abaixo está a 1ª classe Grafos que a gente fez e alguns metodos.....

Estão com alguns erros, pois são apenas as ideias iniciais, mas estes já foram corrigidos nas postagens acima.

----------------------- Classe Grafos

----------------------- Método Gerar grafos

----------------------- Metodo Set Aresta

----------------------- Metodo Imprime Peso

Metodo parentAninhados

O método parentAninhados tem a função de representar graficamente uma arvore binária através de parênteses como mostra a imagem a seguir:

1 – 4: Método que faz interface entre o usuário e a programação para mostrar uma árvore representada graficamente através dos parentes aninhados.
7: Verifica se o nó raiz passado é ou não nulo.
9: Imprimi na tela o “(” mais o valor do nó.
10: Chama recursivamente o método passando o valor do nó filho da esquerda.
11: Chama recursivamente o método passando o valor do nó filho da direita.
12: Imprimi na tela o “)”.

Metodo arvoreHierarquicaII

O método arvoreHierarquicaII tem a função de representar graficamente uma arvore binária através de uma arvore de hereditária como mostra a imagem a seguir:

1 – 4: Método que faz interface entre o usuário e a programação para mostrar uma árvore representada graficamente através dos arvore hierárquica II.
7: Verifica se o nó raiz passado é ou não nulo.
9: Imprimi a variável space que guarda os espaços em branco dados para a identação da árvore e o valor do nó atual.
10: Acrescenta espaços em branco à variável space.
11: Chama recursivamente o método passando o valor do nó filho da esquerda e os espaços em branco guardados em space.
12: Chama recursivamente o método passando o valor do nó filho da direita e os espaços em branco guardados em space.

Metodo arvoreHierarquicaI

O método arvoreHierarquicaI tem a função de representar graficamente uma arvore binária através de uma arvore de hereditária como mostra a imagem a seguir:

A diferença da imagem para como a arvore será representada no programa é que a árvore estará deitada, ou seja, a raiz da arvore ficará na extrema esquerda e a partir daí a arvore vai crescendo para a direita, ao invés de ser feito de cima para baixo.

1 – 4: Método que faz interface entre o usuário e a programação para mostrar uma árvore representada graficamente através dos arvore hierárquica I.
7: Verifica se o nó raiz passado é ou não nulo.
8: Acrescenta espaços em branco à variável space.
9: Chama recursivamente o método passando o valor do nó filho da direita e os espaços em branco guardados em space.
10: Imprimi na tela os espaços em branco que contem na variável space e o valor do nó.
11: Chama recursivamente o método passando o valor do nó filho da esquerda e os espaços em branco guardados em space.
14: No momento em que sai da condição da linha 7, a variável space recebe o caracter de quebra de linha.

Metodo isEstrBinary

O método isEstrBinary consiste em realizar uma verificação para saber se uma árvore é estritamente binária.
Uma árvore estritamente binária é nomeada dessa forma quando os nós têm ou os dois nós filhos ou não tem nenhum.


1 – 4: Método que faz interface entre o usuário e a programação para saber se uma árvore é ou não estritamente binária.
7: Verifica se o nó raiz passado é ou não nulo.
10: Condição que verifica se os nós filhos da esquerda e direita do nó raiz são nulos.
11: Se a verificação acima for verdadeira então o método retorna true.
12: Uma segunda verificação é realizada para saber se os nós filhos da esquerda e direita do nó raiz são diferente de nulos.
14: Condição for verdadeira então verifica se o lado da esquerda e o lado da direita de toda a árvore são estritamente binários.
15: Se a condição for verdadeira então é retornado true
17: Senão false será retornado20: Se a condição da linha 12 for falsa então é retornado false.

Metodo isFull

Uma árvore binária cheia é aquela em que a raiz e todos os nós internos tem dois nós filhos, portanto o objetivo do método isFull é verificar se uma árvore dada pelo usuário é ou não cheia.

O método que da linha 1 até a 10 é o método que faz a interface com o usuário e o código que verifica se a árvore é ou não cheia.
Nesse método de interface há uma diferença dos demais já apresentados:
Nele verificamos a altura dos dois lados da árvore utilizando o método já apresentado height. Se um lado for maior que o outro então não será necessário fazer o restante da verificação e o próprio método de interface retorna false para o usuário.
Se os dois lados da árvore tiverem o mesmo tamanho então chama-se a função de verificação da árvore.

13: Verifica se o nó raiz passado é ou não nulo
15: Se o nó filho direito e esquerdo forem iguais a nulo então retorna o valor true.
16: Se a condição da linha 15 for verdadeira então o valor true é retornado ao método de interface
17: Senão, é feita uma condição que verifica se a árvore do lado direito e do lado esquerdo são verdadeiros.
20: Caso a condição da linha 17 for verdadeira, então o valor true é retornado.
22: Caso contrario é retornado o valor false.
O valor true é retornado quando os nós filhos esquerdo e direito são nulos porque sabemos que o método chegou até o final da árvore. Se no meio do caminho fosse visto que a árvore não é cheia então o valor retornado é false, pois o método não permite que o restante da árvore seja verificada.

Metodo IsDegenerate

Diz-se que uma árvore é degenerada quando ela tem somente um filho. Um bom exemplo de árvore degenerada que temos são as tão famosas pilhas e listas encadeadas que nos colocaram medo por algum tempo.


123 - 126: Método que faz interface entre o usuário e a “real” programação do método.
282: Verifica se a raiz da árvore não é nula.
284: Verifica se o nó em questão tem dois filhos. Se tiver então a árvore não é degenerada.
285: Se a árvore contiver dois filhos então, nesse momento, a função retorna falso.
286: Senão, verifica se existe nó filho da esquerda.
287: Se tiver filho na esquerda então, chama-se a própria função passando como parâmetro o filho da esquerda.
288: Senão, verifica se existe nó filho da direita.
287: Se tiver filho na direita então, chama-se a própria função passando como parâmetro o filho da direita.
288: Quando nenhuma das condições acima satisfazer, então quer dizer que chegou ao final da árvore, e se até o final da árvore o sistema ainda não retornou falso quer dizer que árvore é degenerada e então retorna true.

Metodo Nos Folhas

Os nós folhas de uma árvore são todos os que não possuem nenhum nó filho.
Para descobrirmos qual são os nós filhos, será necessário certificar que o nó não tem nenhum nó filho.

110 – 113: Método que faz interface entre o usuário e a “real” programação do método.
246: Verifica se a raiz da árvore não é nula.
247: Verifica se o nó não tem filho.
248: Se a condição da linha 237 for verdadeira, então o valor do nó é impresso na tela.
250: Faz a chamada do próprio método passando como parâmetro os nós da esquerda.
251: Faz a chamada do próprio método passando como parâmetro os nós da direita.

Fazendo essas duas chamadas recursivas das linhas 240 e 241, consegue-se percorrer toda a árvore para fazer as devidas verificações e imprimir os nós internos dela.

Nós Internos

Os nós internos de uma árvore são todos os nós de uma árvore que tem ao menos um outro nó filho.
Para descobrirmos qual são os nós internos, será necessário verificar se o nó tem ao menos um filho.

105 – 108: Método que faz interface entre o usuário e a “real” programação do método.
236: Verifica se a raiz da árvore não é nula.
237: Verifica se o nó tem ao menos um filho.
238: Se a condição da linha 237 for verdadeira, então o valor do nó é impresso na tela.
240: Faz a chamada do próprio método passando como parâmetro os nós da esquerda.
241: Faz a chamada do próprio método passando como parâmetro os nós da direita.

Fazendo essas duas chamadas recursivas das linhas 240 e 241, consegue-se percorrer toda a árvore para fazer as devidas verificações e imprimir os nós internos dela.

Metodo Height

Este Metodo retorna a altura da arvore.

Para isso, ele usa o metodo MAX.

O Metodo height usa o metodo MAX que tem como finalidade comparar os dois lados da arvore e retornar o maior deles

MAX

374 - Testa se o lado a é maior que o lado b

------ Se Sim

375- Retorna a

------ Se Não

377- Retorna b

Fazendo o teste, o programa guarda sempre o valor do maior lado. Terminada essa função (recursiva) ele soma 1 que é o nó raiz da arvore.

height

110-113 - Metodos que fazem interfaces entre o usuário e o método que contém a programação da funcionalidade

293 - Testa se a raiz é diferente de nulo
------- Se Sim
294 - Soma 1 ao resiltado de MAX
------- Se Não
296 - Retorna 0 e sai da função

Metodo Size

Este metodo retorna a quantidade de valores armazenados na arvore, para isso, ele percorre por toda a arvore usando recursividade.

105-108 - Interface do metodo

277 - Testa se a raiz é diferente de nulo

------ Se Sim

278 - Ele usa recursividade para ir somando os nós das arvores. Ele soma 1 a cada vez q a resposta do teste é positiva, fazendo isso até que o teste dê negativo.

-------Se não

279 - Retorna 0 e sai do programa, mostrando o numero de nós achado.

Maior e Menor

Estes metodos buscam e mostram o maior e o menor nó da arvore, através de recursividade.

Para achar o maior valor, ele busca o nó que está mais a direita, e para achar o menor, o que está mais a esquerda.

95 - 103 - Interfaces dos metodos

244 - Inicio do metodo: maior
246 - Testa se o nó atual é nulo
248 - Testa se o nó direito do atual é nulo
------Se Sim
249 - Retorna o valor do nó
------Se Não
251 - Refaz o teste através de recursividade

259 - Inicio do metodo: menor
261 - Testa se o nó atual é nulo
263 - Testa se o nó esquerdo do atual é nulo
------Se Sim
264 - Retorna o valor do nó
------Se Não
266 - Refaz o teste através de recursividade

MostraPre - MostraPos - MostraCentro

Estes metodos servem para imprimir os nós da arvore. Eles percorrem a arvore, usando recursividade.
Cada um, segue uma ordem, sendo as seguintes

Mostra Pré

Raiz - Sub Arvore Esquerda - Sub Arvore Direita

Mostra Pós

Sub Arvore Esquerda - Sub Arvore Direita - Raiz

Mostra Centro

Sub Arvore Esquerda - Raiz - Sub Arvore Direita

------------------

80 - 93 - Interface dos Metodos
203 / 213 / 223 - Testa se o nó atual é diferente de nulo
205 / 217 / 226 - Imprime os valores do ó atual
206 / 215 / 225 - Percorre as raizes esquerdas (modo recursivo)
207 / 216 / 227 - Percorre as raizes direitas (modo recursivo)

Metodo Push

O Método push insere novos nós a arvore

75 - 78 - Interface do metodo

166 - Testa se o nó atual é nulo
168 - Inicia um novo nó
169 - Atribui o valor que você quer ao novo nó
170 - Atribui valor nulo ao lado esquerdo
171 - Atribui valor nulo ao lado direito
173 - Testa se o valor a ser inserido é maior que o nó atual
- Se Sim...
175 - Atribui o valor a ser inserido a variável aux
177 - Atribui o valor ao nó direito do atual
- Se Não....
181 - Atribui o valor a ser inserido a variável aux
183 - Atribui o valor ao nó esquerdo do atual

Class btree

27 class btree
28 {
29    private:
30       ptrno raiz;
31
32       void push (ptrno &r, int v);
33       void mostraPre(ptrno r);
34       void mostraPos(ptrno r);
35       void mostraCentro(ptrno r);
36       int maior(ptrno r);
37       int menor(ptrno r);
38       int size(ptrno r);
39       int height(ptrno r);
40       void nosInternos(ptrno r);
41       void nosFolhas(ptrno r);
42       bool isDegenerate(ptrno r);
43       bool isComplete(ptrno r);
44       bool isFull(ptrno r);
45       int MAX(int a, int b);
46       bool isEstrBinary(ptrno r);
47       void parentAninhados(ptrno r);
48
49    public:
50       btree()
51       {
52          raiz = NULL;
53       }
54       void push(int v);
55       void mostraPre();
56       void mostraPos();
57       void mostraCentro();
58       int maior();
59       int menor();
60       int size();
61       int height();
62       void nosInternos();
63       void nosFolhas();
64       bool isDegenerate();
65       bool isComplete();
66       bool isFull();
67       bool isEstrBinary();
68       void parentAninhados();
69 };

---------------------------

A Classe btree contém todos os metodos usados nos programas e quais parâmetros ele usa

29 - Private (Área Privada) - Todos os métodos, variaveis e objetos que são criados nessa área só podem ser acessados, ou ter seus valores alterados dentro da propria classe
30 - Declaração do objeto "raiz" tipo ptrno
32-47 - Protótipo dos métodos privados
49 - Public (Área Pública) - Todos os métodos, variaveis e objetos que são criados nessa área podem ser acessados, ou ter seus valores alterados de qualquer outra classe que faça referência a essa
54-68 - Protótipo dos métodos que fazem a interface entre o usuário e a classe

Class Node

A Classe Node manipula os nós das arvores

ptrno - ponteiro para o objeto node

setValor - Atribui valores ao nó atual

setEsq - Atribui valores ao lado Esquerdo

setDir - Atribui valores ao lado Direito

getValor - Ponteiro que retorna o valor do nó atual

getEsq - Ponteiro que retorna o lado esquerdo do nó

getDir- Ponteiro que retorna o lado direito do nó