O documento discute a implementação de árvores binárias em Java. Resume que árvores binárias são estruturas de dados hierárquicas onde cada nó tem no máximo dois filhos, e discute métodos como inserção, busca, remoção e sucessor de nós na árvore.
O documento discute árvores como estruturas de dados, definindo conceitos como raiz, nós, altura e folhas. Explica aplicações de árvores como indexação em bancos de dados e sistemas de arquivos. Também descreve árvores binárias e operações nelas como percorrer, inserir e remover nós.
O documento discute árvores binárias de busca, definindo suas propriedades e operações básicas como busca, inserção e remoção de elementos. Explica que as árvores binárias de busca mantêm uma ordem entre os elementos dos nós, tornando eficiente buscas, inserções e remoções.
O documento descreve árvores binárias, estruturas de dados hierárquicas onde cada nó tem no máximo dois filhos. Explica que uma árvore binária possui uma raiz e nós internos com duas subárvores esquerda e direita, além de nós folha sem filhos. Também apresenta operações básicas como busca, inserção e remoção em árvores binárias de busca, onde os nós são ordenados.
O documento descreve as árvores binárias, incluindo suas propriedades básicas, como grau, altura e tipos de árvores binárias. Também apresenta operações como busca, inserção e remoção em árvores binárias de busca.
O documento discute árvores binárias e suas aplicações. Ele explica como árvores binárias podem ser usadas para encontrar duplicatas em uma lista de números e descreve diferentes métodos para percorrer árvores binárias, como pré-ordem, pós-ordem e em-ordem. Também apresenta árvores binárias de busca e discute operações como inserção e remoção nelas.
Este documento discute árvores binárias de busca (ABB), incluindo:
1) ABBs armazenam dados em uma estrutura de árvore que permite buscas, inserções e remoções eficientes em O(log N).
2) ABBs exigem que todos os nós à esquerda de um nó contenham valores menores e à direita contenham valores maiores.
3) Algoritmos de busca, inserção e contagem em ABBs são apresentados de forma recursiva e não recursiva.
O documento apresenta conceitos sobre árvores binárias. Resume que árvores binárias são estruturas de dados não lineares e hierárquicas onde cada nó pode ter no máximo dois filhos, denominados subárvore esquerda e direita. Além disso, explica termos como raiz, folhas, altura da árvore e operações de percurso como pré-ordem, em-ordem e pós-ordem.
Este documento apresenta o desenvolvimento de uma Árvore Binária de Busca em C, abordando suas principais características, métodos de percurso, busca e remoção de elementos. O autor explica detalhadamente cada etapa da implementação, desde a criação da estrutura de dados até a resolução de exercícios, fornecendo um guia completo para a compreensão e desenvolvimento da estrutura.
O documento discute árvores como estruturas de dados, definindo conceitos como raiz, nós, altura e folhas. Explica aplicações de árvores como indexação em bancos de dados e sistemas de arquivos. Também descreve árvores binárias e operações nelas como percorrer, inserir e remover nós.
O documento discute árvores binárias de busca, definindo suas propriedades e operações básicas como busca, inserção e remoção de elementos. Explica que as árvores binárias de busca mantêm uma ordem entre os elementos dos nós, tornando eficiente buscas, inserções e remoções.
O documento descreve árvores binárias, estruturas de dados hierárquicas onde cada nó tem no máximo dois filhos. Explica que uma árvore binária possui uma raiz e nós internos com duas subárvores esquerda e direita, além de nós folha sem filhos. Também apresenta operações básicas como busca, inserção e remoção em árvores binárias de busca, onde os nós são ordenados.
O documento descreve as árvores binárias, incluindo suas propriedades básicas, como grau, altura e tipos de árvores binárias. Também apresenta operações como busca, inserção e remoção em árvores binárias de busca.
O documento discute árvores binárias e suas aplicações. Ele explica como árvores binárias podem ser usadas para encontrar duplicatas em uma lista de números e descreve diferentes métodos para percorrer árvores binárias, como pré-ordem, pós-ordem e em-ordem. Também apresenta árvores binárias de busca e discute operações como inserção e remoção nelas.
Este documento discute árvores binárias de busca (ABB), incluindo:
1) ABBs armazenam dados em uma estrutura de árvore que permite buscas, inserções e remoções eficientes em O(log N).
2) ABBs exigem que todos os nós à esquerda de um nó contenham valores menores e à direita contenham valores maiores.
3) Algoritmos de busca, inserção e contagem em ABBs são apresentados de forma recursiva e não recursiva.
O documento apresenta conceitos sobre árvores binárias. Resume que árvores binárias são estruturas de dados não lineares e hierárquicas onde cada nó pode ter no máximo dois filhos, denominados subárvore esquerda e direita. Além disso, explica termos como raiz, folhas, altura da árvore e operações de percurso como pré-ordem, em-ordem e pós-ordem.
Este documento apresenta o desenvolvimento de uma Árvore Binária de Busca em C, abordando suas principais características, métodos de percurso, busca e remoção de elementos. O autor explica detalhadamente cada etapa da implementação, desde a criação da estrutura de dados até a resolução de exercícios, fornecendo um guia completo para a compreensão e desenvolvimento da estrutura.
O documento discute tabelas de espalhamento e tratamento de colisões. Resume as principais formas de lidar com colisões em tabelas hash: endereçamento aberto e encadeamento separado. Explica como cada método funciona ao inserir e buscar elementos na tabela.
O documento descreve uma lista duplamente encadeada, onde cada elemento possui referências para o elemento anterior e próximo. A classe Nó armazena o item e as referências prox e ant. A classe ListaDE contém métodos como inserir, remover, pesquisar itens. O método apaga posiciona os nós anterior, atual e próximo do item a remover e atualiza as referências apropriadamente dependendo da posição do item.
O documento descreve listas ligadas e como representá-las em C. Listas ligadas armazenam itens de dados em locais de memória não contíguos, ligados por ponteiros. Isso permite inserções e remoções sem deslocar outros itens, diferente de vetores. Operações como inserir, remover e buscar itens em listas ligadas são explicadas.
O documento descreve as listas encadeadas e como representá-las em C. As listas encadeadas representam uma sequência de objetos na memória ligados por ponteiros. Cada elemento da lista contém um campo de dados e um ponteiro para o próximo elemento, permitindo acesso flexível aos itens.
Estruturas de Dados - Árvores Binárias (Binary Tree) - Parte 2Erick Petrucelli
Material utilizado nas aulas de Estruturas de Dados do curso superior de Tecnologia em Sistemas para Internet da Faculdade de Tecnologia de Taquaritinga, para apoiar a explicação do conceito de Árvore Binária (Binary Tree), com exemplos e implementação prática utilizando JavaScript (com classes do ECMAScript 2015).
O documento descreve as principais características de uma lista simplesmente encadeada. Uma lista simplesmente encadeada é uma estrutura de dados onde cada elemento contém um item de dados e um ponteiro para o próximo elemento. A classe Nós armazena o item e o ponteiro para o próximo nó. A lista pode crescer dinamicamente à medida que novos nós são adicionados e podem ser removidos em qualquer posição.
O documento descreve árvores B, que são estruturas de dados balanceadas utilizadas para armazenamento eficiente em memória secundária. Árvores B mantêm múltiplas chaves em cada nó e organizam ponteiros para permitir buscas, inserções e remoções rápidas. Os nós de uma árvore B podem conter várias chaves e ponteiros para subárvores, e as operações como busca, inserção e remoção são descritas.
Banco de Dados MySQL + NetBeans Java + Interface GraficaDivani Barbosa
O documento fornece instruções sobre como configurar uma interface gráfica Java com NetBeans para exibir e manipular dados armazenados em um banco de dados MySQL usando XAMPP como servidor local. Ele descreve como criar o banco de dados e tabelas, conectar a aplicação Java ao banco de dados, e desenvolver classes para gerenciar conexões, objetos e operações CRUD.
O documento resume as principais estruturas de dados e algoritmos de ordenação e pesquisa, comparando seus tempos de execução no melhor, pior e médio caso e indicando quando cada um é mais apropriado de acordo com características dos dados e necessidades.
A Heap é uma estrutura de dados eficiente para implementar filas de prioridade, oferecendo acesso rápido ao maior item e remoção/inserção em tempo O(logN). Uma Heap é implementada como um vetor que representa uma árvore binária completa, com a raiz no índice zero e o último item no índice n-1, onde cada nó tem uma chave menor que seus pais e maior que seus filhos.
O documento descreve o que é uma heap, como é sua estrutura e operações básicas de inserção e remoção. Uma heap é uma árvore binária balanceada que oferece acesso rápido ao item com a maior chave. Inserção e remoção ocorrem em tempo O(log n) através de movimentação de nós para cima ou para baixo na árvore.
O documento descreve o funcionamento de uma tabela hash, incluindo como realizar inserções, buscas e remoções de elementos de forma eficiente. A tabela hash mapeia chaves para posições de um vetor usando uma função hash, permitindo buscas em tempo constante. Colisões podem ocorrer quando chaves diferentes geram a mesma posição, mas o documento não trata desse caso.
Este documento descreve o uso de pilhas como listas encadeadas para implementar uma calculadora de notação pós-fixa ou polonesa reversa (NPR). Apresenta uma classe PilhaSE que implementa uma pilha como lista encadeada e mostra como usar esta pilha para avaliar expressões matemáticas escritas em notação pós-fixa, empilhando e desempilhando operandos e realizando operações de acordo com os operadores encontrados. Por fim, sugere atividades como melhorar a calculadora e criar um programa para converter notação infixa em
O documento descreve as estruturas de dados do tipo lista, especificamente listas simplesmente encadeadas. Explica que cada elemento da lista contém um item de dados e um elo para o próximo elemento. Apresenta também classes em Java para implementar pilhas e filas como listas encadeadas, com métodos para inserção e remoção de elementos.
Fila de prioridade, pilha e fila são estruturas de dados. Uma fila de prioridade ordena itens por chave, com o de menor chave na frente. Itens são inseridos na posição ordenada e o de maior chave é removido.
O documento descreve o funcionamento de filas circulares. Uma fila circular permite que elementos sejam inseridos e removidos de forma que a remoção de um elemento não altera a posição dos demais, diferentemente de uma fila linear onde todos os elementos precisam ser deslocados. A implementação utiliza um vetor circular onde os índices de início e fim são controlados de forma cíclica.
O documento discute filas como uma estrutura de dados, definindo filas como uma estrutura FIFO onde os itens são inseridos no final e removidos do início. Ele fornece exemplos de implementação de filas em Java com métodos como push(), pop(), front(), size() e empty()/full().
O documento descreve o funcionamento de pilhas, incluindo suas operações básicas de empilhar (push) e desempilhar (pop). As pilhas armazenam itens de acordo com o princípio LIFO, onde o último item inserido é o primeiro a ser removido. O documento também fornece exemplos de implementação de pilhas em Java com métodos como push, pop, top e verificações de tamanho e estado da pilha.
O documento discute estruturas de dados, especificamente registros (ou estruturas) em Java. Ele apresenta exemplos de como declarar uma estrutura para armazenar dados de funcionários com nome, departamento e salário e como criar, ler e imprimir objetos dessa estrutura.
O documento apresenta uma classe Vetor e discute como transformá-la em uma classe VetorStr para armazenar strings. Ele também fornece exemplos de como ler dados do usuário, armazená-los no vetor, buscar itens, remover itens e ordenar o vetor usando o algoritmo QuickSort.
1) O documento discute vários algoritmos de ordenação como BubbleSort, SelectionSort, InsertionSort, MergeSort e QuickSort.
2) O MergeSort é explicado em detalhe, funcionando através da divisão do problema em subproblemas menores e intercalando as partes ordenadas.
3) O QuickSort também é descrito, selecionando um pivô e particionando o vetor em elementos menores e maiores que o pivô.
O documento discute algoritmos de ordenação de dados, incluindo BubbleSort, Selection Sort e Insertion Sort. Explica como cada algoritmo funciona através de exemplos passo a passo e analisa suas complexidades de tempo.
O documento discute tabelas de espalhamento e tratamento de colisões. Resume as principais formas de lidar com colisões em tabelas hash: endereçamento aberto e encadeamento separado. Explica como cada método funciona ao inserir e buscar elementos na tabela.
O documento descreve uma lista duplamente encadeada, onde cada elemento possui referências para o elemento anterior e próximo. A classe Nó armazena o item e as referências prox e ant. A classe ListaDE contém métodos como inserir, remover, pesquisar itens. O método apaga posiciona os nós anterior, atual e próximo do item a remover e atualiza as referências apropriadamente dependendo da posição do item.
O documento descreve listas ligadas e como representá-las em C. Listas ligadas armazenam itens de dados em locais de memória não contíguos, ligados por ponteiros. Isso permite inserções e remoções sem deslocar outros itens, diferente de vetores. Operações como inserir, remover e buscar itens em listas ligadas são explicadas.
O documento descreve as listas encadeadas e como representá-las em C. As listas encadeadas representam uma sequência de objetos na memória ligados por ponteiros. Cada elemento da lista contém um campo de dados e um ponteiro para o próximo elemento, permitindo acesso flexível aos itens.
Estruturas de Dados - Árvores Binárias (Binary Tree) - Parte 2Erick Petrucelli
Material utilizado nas aulas de Estruturas de Dados do curso superior de Tecnologia em Sistemas para Internet da Faculdade de Tecnologia de Taquaritinga, para apoiar a explicação do conceito de Árvore Binária (Binary Tree), com exemplos e implementação prática utilizando JavaScript (com classes do ECMAScript 2015).
O documento descreve as principais características de uma lista simplesmente encadeada. Uma lista simplesmente encadeada é uma estrutura de dados onde cada elemento contém um item de dados e um ponteiro para o próximo elemento. A classe Nós armazena o item e o ponteiro para o próximo nó. A lista pode crescer dinamicamente à medida que novos nós são adicionados e podem ser removidos em qualquer posição.
O documento descreve árvores B, que são estruturas de dados balanceadas utilizadas para armazenamento eficiente em memória secundária. Árvores B mantêm múltiplas chaves em cada nó e organizam ponteiros para permitir buscas, inserções e remoções rápidas. Os nós de uma árvore B podem conter várias chaves e ponteiros para subárvores, e as operações como busca, inserção e remoção são descritas.
Banco de Dados MySQL + NetBeans Java + Interface GraficaDivani Barbosa
O documento fornece instruções sobre como configurar uma interface gráfica Java com NetBeans para exibir e manipular dados armazenados em um banco de dados MySQL usando XAMPP como servidor local. Ele descreve como criar o banco de dados e tabelas, conectar a aplicação Java ao banco de dados, e desenvolver classes para gerenciar conexões, objetos e operações CRUD.
O documento resume as principais estruturas de dados e algoritmos de ordenação e pesquisa, comparando seus tempos de execução no melhor, pior e médio caso e indicando quando cada um é mais apropriado de acordo com características dos dados e necessidades.
A Heap é uma estrutura de dados eficiente para implementar filas de prioridade, oferecendo acesso rápido ao maior item e remoção/inserção em tempo O(logN). Uma Heap é implementada como um vetor que representa uma árvore binária completa, com a raiz no índice zero e o último item no índice n-1, onde cada nó tem uma chave menor que seus pais e maior que seus filhos.
O documento descreve o que é uma heap, como é sua estrutura e operações básicas de inserção e remoção. Uma heap é uma árvore binária balanceada que oferece acesso rápido ao item com a maior chave. Inserção e remoção ocorrem em tempo O(log n) através de movimentação de nós para cima ou para baixo na árvore.
O documento descreve o funcionamento de uma tabela hash, incluindo como realizar inserções, buscas e remoções de elementos de forma eficiente. A tabela hash mapeia chaves para posições de um vetor usando uma função hash, permitindo buscas em tempo constante. Colisões podem ocorrer quando chaves diferentes geram a mesma posição, mas o documento não trata desse caso.
Este documento descreve o uso de pilhas como listas encadeadas para implementar uma calculadora de notação pós-fixa ou polonesa reversa (NPR). Apresenta uma classe PilhaSE que implementa uma pilha como lista encadeada e mostra como usar esta pilha para avaliar expressões matemáticas escritas em notação pós-fixa, empilhando e desempilhando operandos e realizando operações de acordo com os operadores encontrados. Por fim, sugere atividades como melhorar a calculadora e criar um programa para converter notação infixa em
O documento descreve as estruturas de dados do tipo lista, especificamente listas simplesmente encadeadas. Explica que cada elemento da lista contém um item de dados e um elo para o próximo elemento. Apresenta também classes em Java para implementar pilhas e filas como listas encadeadas, com métodos para inserção e remoção de elementos.
Fila de prioridade, pilha e fila são estruturas de dados. Uma fila de prioridade ordena itens por chave, com o de menor chave na frente. Itens são inseridos na posição ordenada e o de maior chave é removido.
O documento descreve o funcionamento de filas circulares. Uma fila circular permite que elementos sejam inseridos e removidos de forma que a remoção de um elemento não altera a posição dos demais, diferentemente de uma fila linear onde todos os elementos precisam ser deslocados. A implementação utiliza um vetor circular onde os índices de início e fim são controlados de forma cíclica.
O documento discute filas como uma estrutura de dados, definindo filas como uma estrutura FIFO onde os itens são inseridos no final e removidos do início. Ele fornece exemplos de implementação de filas em Java com métodos como push(), pop(), front(), size() e empty()/full().
O documento descreve o funcionamento de pilhas, incluindo suas operações básicas de empilhar (push) e desempilhar (pop). As pilhas armazenam itens de acordo com o princípio LIFO, onde o último item inserido é o primeiro a ser removido. O documento também fornece exemplos de implementação de pilhas em Java com métodos como push, pop, top e verificações de tamanho e estado da pilha.
O documento discute estruturas de dados, especificamente registros (ou estruturas) em Java. Ele apresenta exemplos de como declarar uma estrutura para armazenar dados de funcionários com nome, departamento e salário e como criar, ler e imprimir objetos dessa estrutura.
O documento apresenta uma classe Vetor e discute como transformá-la em uma classe VetorStr para armazenar strings. Ele também fornece exemplos de como ler dados do usuário, armazená-los no vetor, buscar itens, remover itens e ordenar o vetor usando o algoritmo QuickSort.
1) O documento discute vários algoritmos de ordenação como BubbleSort, SelectionSort, InsertionSort, MergeSort e QuickSort.
2) O MergeSort é explicado em detalhe, funcionando através da divisão do problema em subproblemas menores e intercalando as partes ordenadas.
3) O QuickSort também é descrito, selecionando um pivô e particionando o vetor em elementos menores e maiores que o pivô.
O documento discute algoritmos de ordenação de dados, incluindo BubbleSort, Selection Sort e Insertion Sort. Explica como cada algoritmo funciona através de exemplos passo a passo e analisa suas complexidades de tempo.
O documento discute recursividade e como resolver problemas de forma recursiva. Explica que uma função recursiva é aquela que se chama a si mesma e que a recursividade envolve dividir um problema em subproblemas menores do mesmo tipo até chegar a um caso trivial. Fornece como exemplo a função fatorial definida recursivamente.
O documento descreve a estrutura de dados vetor em Java, incluindo como criar, inserir, exibir, pesquisar e remover itens de um vetor. É apresentada uma classe Vetor que encapsula as operações em vetores e um programa principal que usa essa classe para demonstrar seus métodos.
O documento apresenta uma introdução sobre a linguagem Java, definindo-a como uma linguagem de programação de alto nível, interpretada e orientada a objetos. Também apresenta alguns comandos básicos do NetBeans IDE e conceitos fundamentais como variáveis, tipos de dados, declaração, atribuição e operadores matemáticos.
A linguagem C# aproveita conceitos de muitas outras linguagens,
mas especialmente de C++ e Java. Sua sintaxe é relativamente fácil, o que
diminui o tempo de aprendizado. Todos os programas desenvolvidos devem
ser compilados, gerando um arquivo com a extensão DLL ou EXE. Isso torna a
execução dos programas mais rápida se comparados com as linguagens de
script (VBScript , JavaScript) que atualmente utilizamos na internet
As classes de modelagem podem ser comparadas a moldes ou
formas que definem as características e os comportamentos dos
objetos criados a partir delas. Vale traçar um paralelo com o projeto de
um automóvel. Os engenheiros definem as medidas, a quantidade de
portas, a potência do motor, a localização do estepe, dentre outras
descrições necessárias para a fabricação de um veículo
2. 2
É uma estrutura de dados caracterizada por:
Ou não tem elemento algum (árvore vazia).
Ou tem um elemento distinto, denominado raiz, com dois
apontamentos para dois elos diferentes, denominadas sub-
árvore esquerda e sub-árvore direita.
Arvore Binária
Exemplos:
a) b)
4. 4
Arvores Balanceadas
Uma arvore é considerada balanceada quando suas sub-
arvores a esquerda e a direita possuem a mesma altura.
A arvore não balanceada é definida como degenerada.
Exemplos:
arvore binária
balanceada
arvore binária
degenerada
a) b)
5. 5
Classe No
Uma arvore binária precisa de uma classe de
objetos Nós, assim como vimos na lista
duplamente encadeada:
class No {
public long item;
public No esq;
public No dir;
}
espaço para armazenamento da
informação (chave)
Um espaço para armazenar uma
referência da localização na
memória onde o Nó a esquerda
se encontra.
Um espaço para armazenar a
referência do Nó a direita.
6. 6
Nó
esq =
dir =
item = 14
Nó
esq =
dir =
item = 4
Nó
esq =
dir =
item = 16
Nó
esq = NULL
dir = NULL
item = 3
Nó
esq = NULL
dir = NULL
item = 9
Nó
esq = NULL
dir = NULL
item = 15
Nó
esq = NULL
dir = NULL
item = 18
As referencias
são para outras
sub-arvores
root
Elos de uma arvore binária
7. 7
Nó
esq =
dir =
item = 14
Nó
esq =
dir =
item = 4
Nó
esq =
dir =
item = 16
Nó
esq = NULL
dir = NULL
item = 3
Nó
esq = NULL
dir = NULL
item = 9
Nó
esq = NULL
dir = NULL
item = 15
Nó
esq = NULL
dir = NULL
item = 18
root = null
A árvore pode não ter nenhum elemento (árvore vazia)
Elos de uma arvore binária
8. 8
Implementação
private No root;
Classe Tree:
Campo Construtor
public Tree() { root=null; }
Métodos
inserir: Insere itens na arvore
buscar: Retorna Nó procurado ou null
remover: Retorna verdadeiro se removeu item
no_sucessor: Retorna o Nó sucessor ao passado no
parâmetro
caminhar: (inOrder, preOrder, posOrder, altura,
folhas, min, max, contarNos)
9. Método: inserir
A inserção começa com a chave sendo atribuida a raiz,
logo após a função começa com uma busca, a-partir da
raiz, comparando a chave com o valor da raiz. Se a
chave é menor ou igual do que a raiz, ela é
introduzida num novo nó a esquerda da raiz, ou na
direita caso a chave seja maior que a raiz, e assim
sucessivamente, item a item, os nós são criados.
Exemplo:
Itens a serem adicionados:
25, 11, 42, 6, 19, 37 e 14
10. Método: inserir
public void inserir(long v) {
No novo = new No();
novo.item = v;
novo.dir = null;
novo.esq = null;
if (root == null)
root = novo;
else {
// inserir aqui
// trecho de código
// para tratamento
// caso árvore não vazia
}
}
Entrada: item que deseja inserir Saída: não há
Criando objeto Nó e
armazenando na referencia
novo
se arvore vazia
11. No atual = root;
No anterior;
while (true) {
anterior = atual;
if (v <= atual.item) {
atual = atual.esq;
if (atual == null) {
anterior.esq = novo;
return; }
}
else {
atual = atual.dir;
if (atual == null) {
anterior.dir = novo;
return; }
}
} // fim do laço while
trecho de código para tratamento caso não raiz (arvore não vazia)
começa a procurar desde raiz
Adiciona a esquerda
e sai
Adiciona a direita
e sai
Caminha para esquerda
Caminha para direita
Guarda o Nó anterior
12. 12
Método: buscar
public No buscar(long chave) {
if (root == null) return null;
No atual = root;
while (atual.item != chave) {
if (chave < atual.item )
atual = atual.esq;
else
atual = atual.dir;
if (atual == null)
return null;
}
return atual;
}
Entrada: chave
Saída: Nó que procura ou null caso não encontre a chave
começa a procurar desde raiz
se arvore vazia
enquanto nao encontrou
caminha para esquerda
caminha para direita
encontrou uma folha -> sai
Saiu do laço while e chegou
aqui é porque encontrou item
13. Método: remover
O processo de exclusão de um nó é o mais complexo.
Para excluir um nó de uma árvore binária, deve-se
considerar três casos distintos:
Remoção da folha
A exclusão de um nó que se encontra no fim da árvore, isto é, na
folha, é o caso mais simples de exclusão. Basta remover o nó da
árvore
14. 14
Remoção de um nó com “filho”
Caso o nó que será excluído tenha um único "filho", o "avô"
herda o "filho".
15. 15
Remoção de um nó com dois “filhos”
Se o nó a ser excluído tiver dois "filhos", o processo de
exclusão poderá operar de duas maneiras diferentes:
Substituir o valor do nó a ser retirado pelo valor sucessor (o
nó mais à esquerda da sub-árvore direita).
16. Método: remover
public boolean remover(long v) {
if (root == null) return false;
No atual = root;
No pai = root;
boolean filho_esq = true;
while ( atual.item != v) {
pai = atual;
if ( v < atual.item ) {
atual = atual.esq;
filho_esq = true;
} else {
atual = atual.dir;
filho_esq = false;
}
if (atual == null) return false;
} // fim laço while busca
Entrada: item que deseja remover
Saída: verdadeiro ou falso
Enquanto não encontrou
Caminha a esquerda
Caminha a direita
Chegou em uma folha
17. public boolean remover(long v) {
if (root == null) return false;
No atual = root;
No pai = root;
boolean filho_esq = true;
while ( atual.item != v) {
pai = atual;
if ( v < atual.item ) {
atual = atual.esq;
filho_esq = true;
} else {
atual = atual.dir;
filho_esq = false;
}
if (atual == null) return false;
} // fim laço while busca
Método: remover
Entrada: item que deseja remover
Saída: verdadeiro ou falso
Se terminou o laço de busca
sem sair do método remover
quer dizer que:
Encontrou o valor (v)
"atual": contem a
referencia ao No a ser
eliminado
"pai": contem a
referencia para o pai do
No a ser eliminado
"filho_esq": é
verdadeiro se atual é filho
a esquerda do pai
18. Método: remover
Entrada: item que deseja remover
Saída: verdadeiro ou falso
atual.item =
pai.item =
filho_esq =
atual.item = 11
pai.item = 25
filho_esq = true
public boolean remover(long v) {
if (root == null) return false;
No atual = root;
No pai = root;
boolean filho_esq = true;
while ( atual.item != v) {
pai = atual;
if ( v < atual.item ) {
atual = atual.esq;
filho_esq = true;
} else {
atual = atual.dir;
filho_esq = false;
}
if (atual == null) return false;
} // fim laço while busca
19. if (atual.esq == null && atual.dir == null)
{
if (atual == root ) root = null;
else if (filho_esq) pai.esq = null;
else pai.dir = null;
}
Eliminando uma folha
atual.item = 6
pai.item = 11
filho_esq = true
Se não possui nenhum filho (é uma folha), elimine-o
20. Se é pai e não possui filho a direita
atual.item = 19
pai.item = 11
filho_esq = false
Substitui pela sub-árvore a direita
else if (atual.dir == null) {
if (atual == root) root = atual.esq;
else if (filho_esq) pai.esq = atual.esq;
else pai.dir = atual.esq;
}
pai.dir
atual.esq
21. Se é pai e não possui filho a esquerda
atual.item = 6
pai.item = 11
filho_esq = true
Substitui pela sub-árvore a esquerda
else if (atual.esq == null) {
if (atual == root) root = atual.dir;
else if (filho_esq) pai.esq = atual.dir;
else pai.dir = atual.dir;
}
pai.esq
atual.dir
22. Se possui mais de um filho
Se for um avô ou outro grau maior de parentesco
else {
No sucessor = no_sucessor(atual);
if (atual == root) root = sucessor;
else if (filho_esq) pai.esq = sucessor;
else pai.dir = sucessor;
sucessor.esq = atual.esq;
}
return true; // removeu item retorna true
} // fim método remover
Usando sucessor que seria a referencia ao Nó mais a esquerda da sub-
árvore a direita do Nó que deseja-se remover
24. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Retorno:
apaga
paisucessor
sucessor
atual
Entrada:
25. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Retorno:
apaga
sucessor
atual
paisucessor
sucessor
atual
Entrada:
paisucessor
26. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Retorno:
apaga
sucessor
atual
paisucessor
sucessor
atual
Entrada:
paisucessor
sucessor
atual = null
true
27. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Retorno:
apaga
sucessor
atual
paisucessor
sucessor
atual
sucessor
atual = null
Entrada:
true
paisucessor
sucessor
28. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Retorno:
apaga
sucessor
atual
paisucessor
sucessor
atual = null
Entrada:
true
paisucessor
sucessor
null
29. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
sucessor
apaga
paisucessor
sucessor
atual
paisucessor
sucessor
atual = null
Entrada:
true
null
apaga.dir
Retorno:
30. atual.item = 11
pai.item = 25
filho_esq = true
pai.esq
No sucessor = no_sucessor(atual);
if (atual == root) root = sucessor;
else if (filho_esq) pai.esq = sucessor;
else pai.dir = sucessor;
sucessor.esq = atual.esq;
Trecho de código
1
2
3
4
5
sucessor
pai.esq = sucessor
Linha 3:
atual.esq
31. atual.item = 11
pai.item = 25
filho_esq = true
pai.esq
atual.esq
Trecho de código
1
2
3
4
5
pai.esq = sucessor
Linha 3:
sucessor
No sucessor = no_sucessor(atual);
if (atual == root) root = sucessor;
else if (filho_esq) pai.esq = sucessor;
else pai.dir = sucessor;
sucessor.esq = atual.esq;
32. pai.esq
atual.esq
Trecho de código
1
2
3
4
5
pai.esq= sucessor
Linha 3: Linha 5:
sucessor.esq =
atual.esq
sucessor sucessor
No sucessor = no_sucessor(atual);
if (atual == root) root = sucessor;
else if (filho_esq) pai.esq = sucessor;
else pai.dir = sucessor;
sucessor.esq = atual.esq;
33. public No no_sucessor(No apaga) {
No paidosucessor = apaga;
No sucessor = apaga;
No atual = apaga.dir;
while (atual != null) {
paidosucessor = sucessor;
sucessor = atual;
atual = atual.esq;
}
if (sucessor != apaga.dir) {
paidosucessor.esq = sucessor.dir;
sucessor.dir = apaga.dir;
}
return sucessor;
}
Método: no_sucessor
Vai para a sub-
arvore a direita
Caminha para o Nó
mais a esquerda
Se sucessor não é
o filho a direita do
Nó que deverá ser
eliminado
Pai herda os filhos
do sucessor que
sempre serão a
direita
Guardando a
referencia a direita
do sucessor para
quando ele
assumir a posição
correta na arvore
34. 34
Método: caminhar
public void caminhar() {
System.out.print("n Exibindo em ordem: ");
inOrder(root);
System.out.print("n Exibindo em pos-ordem: ");
posOrder(root);
System.out.print("n Exibindo em pre-ordem: ");
preOrder(root);
System.out.print("n Altura da arvore: " + altura(root));
System.out.print("n Quantidade de folhas: " + folhas(root));
System.out.print("n Quantidade de Nós: " + contarNos(root));
if (root != null ) { // se arvore nao esta vazia
System.out.print("n Valor minimo: " + min().item);
System.out.println("n Valor maximo: " + max().item);
}
}
Chamada a métodos recursivos
Entrada: Não há
Saída: Não tem
35. 35
Método: inOrder
public void inOrder(No atual) {
if (atual != null) {
inOrder(atual.esq);
System.out.print(atual.item + " ");
inOrder(atual.dir);
}
}
Primeiro visita o Nó a esquerda, depois a raiz (imprime o
item), finalizando com o Nó a direita.
Entrada: O Nó raiz
Saída: Não tem retorno
36. 36
Método: posOrder
public void posOrder(No atual) {
if (atual != null) {
posOrder(atual.esq);
posOrder(atual.dir);
System.out.print(atual.item + " ");
}
}
Primeiro visita o Nó a esquerda, depois o Nó a direita,
finalizando com a raiz (imprime o item).
Entrada: O Nó raiz
Saída: Não tem retorno
37. 37
Método: preOrder
public void preOrder(No atual) {
if (atual != null) {
System.out.print(atual.item + " ");
preOrder(atual.esq);
preOrder(atual.dir);
}
}
Primeiro visita a raiz (imprime o item), depois o Nó a
esquerda, finalizando com o Nó a direita.
Entrada: O Nó raiz
Saída: Não tem retorno
38. 38
Método: folhas
public int folhas(No atual) {
if (atual == null) return 0;
if (atual.esq == null && atual.dir == null)
return 1;
return folhas(atual.esq) + folhas(atual.dir);
}
Entrada: O Nó raiz
Saída: Numero de folhas da arvore
39. 39
Método: folhas
public int folhas(No atual) {
if (atual == null) return 0;
if (atual.esq == null && atual.dir == null)
return 1;
return folhas(atual.esq) + folhas(atual.dir);
}
Entrada: O Nó raiz
Saída: Numero de folhas da arvore
A arvore não possui itens ou chegou no final e não encontrou mais nenhum item
retorna zero
Retorne chamada recursiva da função contando a quantidade de folhas a
esquerda mais a direita da arvore
Se encontrou somente um item (raiz) ou chegou em uma folha,
retorna 1
40. 40
Método: contarNos
public int contarNos(No atual) {
if (atual == null)
return 0;
else
return ( 1 + contarNos(atual.esq) +
contarNos(atual.dir) );
}
Entrada: O Nó raiz
Saída: Numero de Nós
Arvore vazia ou chegou no final e não encontrou mais nenhum item retorna zero
Senão retorne o valor 1 + chamada recursiva da função
contando a quantidade de nós a esquerda mais a direita da
arvore
41. 41
Método: min
public No min() {
No atual = root;
No anterior = null;
while (atual != null) {
anterior = atual;
atual = atual.esq;
}
return anterior;
}
Entrada: não há
Saída: No mais a esquerda (Nó mínimo)
42. 42
Método: min
public No min() {
No atual = root;
No anterior = null;
while (atual != null) {
anterior = atual;
atual = atual.esq;
}
return anterior;
}
Entrada: não há
Saída: No mais a esquerda (Nó mínimo)
Começa na raiz
Enquanto não encontrar um Nó
igual a null
Guarda o Nó anterior
Caminha para o filho a esquerda
43. 43
Método: max
public No max() {
No atual = root;
No anterior = null;
while (atual != null) {
anterior = atual;
atual = atual.dir;
}
return anterior;
}
Entrada: não há
Saída: No mais a direita (Nó máximo)
44. 44
Método: max
public No max() {
No atual = root;
No anterior = null;
while (atual != null) {
anterior = atual;
atual = atual.dir;
}
return anterior;
}
Entrada: não há
Saída: No mais a direita (Nó máximo)
Começa na raiz
Enquanto não encontrar um Nó
igual a null
Guarda o Nó anterior
Caminha para o filho a direita
45. Exemplo de uso da classe Tree:
class TreeBinApp {
public static void main(String[] args) {
Scanner le = new Scanner(System.in);
Tree arv = new Tree();
int opcao;
long x;
System.out.print("n Programa Arvore binaria de long");
do {
System.out.print("n***********************************");
System.out.print("nEntre com a opcao:");
System.out.print("n ----1: Inserir");
System.out.print("n ----2: Excluir");
System.out.print("n ----3: Pesquisar");
System.out.print("n ----4: Exibir");
System.out.print("n ----5: Sair do programa");
System.out.print("n***********************************");
System.out.print("n-> ");
opcao = le.nextInt();
switch(opcao) {
case 1: {
System.out.print("n Informe o valor (long) -> ");
x = le.nextLong();
46. x = le.nextLong();
arv.inserir(x);
break;
}
case 2: {
System.out.print("n Informe o valor (long) -> ");
x = le.nextLong();
if ( !arv.remover(x) )
System.out.print("n Valor nao encontrado!");;
break;
}
case 3: {
System.out.print("n Informe o valor (long) -> ");
x = le.nextLong();
if( arv.buscar(x) != null )
System.out.print("n Valor Encontrado");
else
System.out.print("n Valor nao encontrado!");
break;
}
case 4: {
arv.caminhar();
break;
}
48. 48
Atividades
1. No código Java para uma árvore, o ________ e a ________
são geralmente classes separadas.
.2. Uma sub-árvore de uma árvore binária sempre tem
(a) Uma raiz que é um filho da raiz da árvore principal
(b) Uma raiz não conectada a raiz da árvore principal
(c) Menos Nós que a árvore principal
(d) Uma irmã com mesmo número de Nós
3. Verdadeiro ou falso:
(a) Eliminar um Nó com um filho de uma árvore binária de busca envolve
encontrar o sucessor desse Nó.
(b) Nem todas as árvores são binárias.
(c) Uma árvore não balanceada é uma árvore na qual a raiz ou algum
outro Nó tenha muito mais filhos à esquerda do que filhos à direita ou
vice-versa.
49. 49
Atividades
4. Trabalho 2 - Exercício 6. Desenhe uma arvore binária
usando a seguinte sequencia de dados de entrada:
(a) 25, 11, 42, 6, 19, 37 e 14
(b) 11, 22, 33, 44, -11, -33 e -22
(c) 14, 4, 15, 3, 9, 13, 18, 7, 11, 16, 20, 5, 17, 4 e 5
Responda: Quantas folhas, nós e qual a altura das arvores (a), (b) e (c).
Escreva a arvore (b) e (c) em pré-ordem e pós-ordem.
Desenhe as arvores (a), (b) e (c) depois da inserção do nó 21 e da
remoção do nó 11 para as arvores (a) e (b) e nó 18 para arvore (c).
5. Desenvolva um programa árvore binária de:
(a) double
(b) caracteres
(c) strings
50. 50
Atividades
6. Desenvolva um programa árvore binária para um objeto
que represente uma agenda telefônica, use o nome como
campo chave