Árvores Binárias

ATAI

1
Árvore Binária

Árvore Binária é uma Árvore de grau 2.

Os elementos da Árvore Binária são os nós.

Cada nó contem informação sobre o elemento (que é identificado

pela sua chave única), o filho da esquerda e o filho da direita.

A Árvore Binária pode estar vazia.

A relação entre os elementos é hierárquico. Existe um único nó

raiz. Cada nó (com excepção do nó raiz) possui um único nó pai.
Cada nó pode ter dois ou zero filhos (uma árvore própria).

2
Propriedades de uma Árvore Binária
altura no
0 1

1 2

2 4

3 8

sendo T, uma árvore binária de altura h:

1. h+1  # folhas  2h
2. h  # nós internos  2h -1
3. 2h+1  # nós em T  2h+1 - 1
4. log(n+1)-1  altura de T  (n-1)/2

3
 Percurso Pre-ordem
Passos
1. Processar o nó
2. Percorrer em pre-ordem a sub-
árvore esquerda
3. Percorrer em pre-ordem a sub- A
árvore direira

void preOrder ( ) { preOrder(root); }

B C
void preOrder ( Node v )
{
if ( v != null )
{
D E F
.:
process(v);
Ordem dos nós visitados: A B D E C F
preOrder(v.left);
preOrder(v.right);
}
}

4
 Percurso Pos-ordem
Passos:
1. Percorrer em pos-ordem a sub-
árvore esquerda
2. Percorrer em pos-ordem a sub-
árvore direita
A
3. Processar o nó

void postOrder ( ) { postOrder(root); }

B C
void postOrder ( Node v )
{
if ( v != null )
D E F
{
postOrder(v.left);
postOrder(v.right);
Ordem dos nós visitados : D E B F C A
// process element at v, e.g.:
process(v);
}
}

5
 Percurso In-ordem
Passos
1. Percorrer em in-ordem a sub-
árvore esquerda
2. Processar o nó
3. Percorrer em in-ordem a sub- A
árvore direita

void inOrder ( ) { inOrder(root); }

B C
void inOrder ( Node v )
{
if ( v != null )
D E F
{
inOrder(v.left);
// process element at v, e.g.:
Ordem dos nós visitados : D B E A F C
process(v);
inOrder(v.right);
}
}

6
Percorrer uma árvore de um modo iterativo
// algoritmos iterativo preOrder

Uso de um loop: void preOrder ()

 Armazenamento temporário {
de informação de modo a Stack S = new Stack();
permitir o percurso desejado Node v;
 Uso de uma pilha
S.push(tree);
do {
v = (Node) S.pop();
if ( v != null )
{
process(v);
S.push(v.right);
S.push(v.left);
}
} while (! S.isEmpty());
}

7
 Operações Recursivas
A maior parte das operação pode ser
implementada de um modo elegante
atravês do uso da recursividade
int height ( ) { return height(root); }

BinTree copyTree( ) int height ( Node v )

{ {
BinTree t = new BinTree(); if ( v == null )
t.root = copy(root); return 0;
return t; else
} return (1 + Math.max(height(v.left),
height(v.right)) );
Node copy ( Node v ) }
{
if ( v == null )
return null;
else
return ( new Node(v.value, copy(v.left), copy(v.right) );
}

8
Uso de árvore de expressões
3*8+7
Percorrer a árvore binária:

• in-ordem
infix : 3*8+7
+
• pre-order
prefix : +*387

* 7 • post-order
postfix : 3 8 * 7 +

3 8

As folhas contêm operandos e os outros

nós contêm operadores

9
 Árvore Binária
Implementação Estática

Armazenamento por nível:

    posição do nó    posição dos filhos do
1               2,3
 2               4,5
 3               6,7
       i             (2i,2i+1)

10
ADT BinaryTree

public interface BinaryTree

extends InspectableBinaryTree,
PositionalContainer {
}

public interface InspectableBinaryTree extends

InspectableTree {
// accessor methods
/** return the left child of a node */
public Position leftChild (Position v);

/** return the right child of a node */

public Position rightChild (Position v);

/** return the sibling of a node */

public Position sibling (Position v);
}

11
 Árvore Binária
Implementação Dinâmica
/** Node of a binary tree */
public class BTNode implements Position {
private Object element;
private BTNode left, right, parent;
/** default constructor */
public BTNode() { }
/** constructor with parameters */
public BTNode (Object o, BTNode u, BTNode v, BTNode w) {
setElement(o);
setParent(u);
setLeft(v);
setRight(w);
}
public Object element() { return element; }
public void setElement (Object o) { element=o; }
public BTNode getLeft() { return left; }
public void setLeft(BTNode v) { left=v; }
public BTNode getRight() { return right; }
public void setRight(BTNode v) { right=v; }
public BTNode getParent() { return parent; }
public void setParent(BTNode v) { parent=v; }
}

12
 Árvore Binária
Implementação Dinâmica
public class LinkedBinaryTree implements BinaryTree {
private Position root; // reference to the root
private int size; // number of nodes

public LinkedBinaryTree() {
root = new BTNode(null,null,null,null);
size = 0;
}

public int size() { return size; }

public boolean isEmpty() { return (size==0); }
public boolean isInternal(Position v) {
return (((BTNode) v).getLeft()!=null && ((BTNode) v).getRight()!=null);
}
public boolean isExternal(Position v) {
return (((BTNode) v).getLeft()==null && ((BTNode) v).getRight()==null);
}
public boolean isRoot(Position v) { return (v==root()); }

13
 Árvore Binária
Implementação Dinâmica
public Position root() { return root; }

public PositionIterator positions() {

Position[] positions = new Position[size()];
inorderPositions(root(), positions, 0);
return new ArrayPositionIterator(positions);
}

public Position leftChild(Position v) { return ((BTNode) v).getLeft(); }

public Position rightChild(Position v) { return ((BTNode) v).getRight(); }

public Position sibling(Position v) {

Position p = parent(v);
Position lc = leftChild(p);
if (v == lc)
return rightChild(p);
else
return lc;
}

public Position parent (Position v) { return ((BTNode) v).getParent(); }

14