Cátia Vaz

Tipos de Dados Abstratos
Algoritmos e Estruturas de Dados
Verão 2012
Cátia Vaz
1

Tipos Abstratos
n Um tipo abstrato é:
n
n
n
um tipo genérico de dados, dos quais não se conhece os
valores
uma interface que define os acessos e as operações sobre
os dados
O conjunto das propriedades algébricas da interface, que
delimitam as possíveis implementações.
n
n
Um programa que usa um tipo abstrato é um
cliente. O cliente não tem acesso à implementação.
Um programa que especifique o tipo de dados é
uma implementação.
Cátia Vaz
2

Pilha - Stack
n
Operações abstratas:
n
n
n
n
inicialização;
colocação de um elemento na pilha;
remoção de um elemento (o último colocado); LIFO
indicar se pilha está vazia.
n interface para uma pilha que contenha inteiros:
public interface intStack{
public boolean empty();
public void push(int i);
}
várias
public int pop();
Usando a mesma interface,
podem ser definidas
implementações!
Cátia Vaz
3

Pilha - Stack
n
Operações abstratas:
n
n
n
n
inicialização;
colocação de um elemento na pilha;
remoção de um elemento (o último colocado); LIFO
indicar se pilha está vazia.
n interface para uma pilha genérica:
public interface Stack< E > {
public boolean isEmpty();
}
public E push(E i);
várias
implementações!
public E pop();
public E peek();
Usando a mesma interface,
podem ser definidas
Cátia Vaz
4

Pilha (Stack) - inserção
5

Pilha (Stack) - remoção
6

Implementação do tipo pilha
usando um array
//Não compila!!
public class StackArray implements Stack{
private E[] s;
private int top;
public StackArray(int capacity) {
s=new E[capacity];
}
//! a criação de um array genérico não é permitida em Java
public boolean isEmpty(){ return top == 0; }
public E peek() {
if(isEmpty()) throw new EmptyStackException();
return s[top-1]; }
}
public E push(E item) {
if( top == s.length ) return null;
s[top++] = item; return item;
}
public E pop() {
if(isEmpty()) throw new EmptyStackException();
E e = s[--top]; s[top] = null;
return e;
}
Cátia Vaz
7

Implementação do tipo pilha
usando um array
public class StackArray implements Stack{
private E[] s;
private int top;
public StackArray(int capacity) {
s= ( E[] ) new Object[capacity]; //solução!
}
public boolean isEmpty(){ return top == 0; }
public E peek() {
if(isEmpty()) throw new EmptyStackException();
}
return s[top-1]; }
public E push(E item) {
if( top == s.length ) return null;
s[top++] = item; return item;
}
public E pop() {
if(isEmpty()) throw new EmptyStackException();
E e = s[--top]; s[top] = null;
return e;
}
Vantagens: simplicidade.
Desvantagens: tamanho
máximo limitado à partida.
Cátia Vaz
8

Lista Simplesmente Ligada
n
n
Uma lista ligada é uma colecção de objectos, designados por
nós , em que cada um contêm dados e apenas uma referência
para outro nó, de modo a formarem uma lista. O primeiro nó é
designado por head node.
Uma lista ligada diz-se simplesmente ligada quando cada nó
contém uma referência para o próximo nó.
private class Node{
private E data;
private Node next;
...
}
Exemplo:
:SLinkedList
head
:Node
item
next
“c”
:Node
item
next
“g”
null
Cátia Vaz
9

Implementação do tipo pilha
usando um lista ligada
public class StackList implements Stack{
private static class Node {
E item; Node next;
Node(E i, Node n){ item=i; next = n;}
}
private Node head;
public boolean isEmpty() {return head == null; }
public E peek() {
if(isEmpty()) throw new EmptyStackException();
return head.item; }
public E push(E item) {
head = new Node(item, head);
return item;
}
public E pop() {
if(isEmpty()) throw new EmptyStackException();
E item = head.item;
head = head.next;
return item;
}
}
Vantagens:
- aumenta e diminui consoante se
inserem ou removem novos
elementos na pilha.
Desvantagens:
- ocupa mais memória.
- acesso mais lento.
Cátia Vaz
10

Que estrutura de dados
escolher?
§ Depende :
n
n
das operações que sejam mais frequentes no algoritmo a
implementar:
n Se a escolha for entre arrays e listas, dever-se-á escolher:
n
n
n
n
arrays se forem predominantes as operações de acesso e
modificação;
listas se forem predominantes as operações de inserção e
remoção.
Usar listas simples, se estas operações ocorrem sempre no início.
Usar listas simples com ponteiro adicional para o fim da lista,
se a inserção se fizer no fim e a remoção no início.
da previsibilidade sobre a memória necessária:
n o uso de arrays pressupõe que se saiba que memória é
suficiente;
n quando não é previsível é necessário gerir a memória
dinamicamente.
Cátia Vaz
11

PriorityQueue
public interface PriorityQueue{
public void add(E elem, P prio, KeyExtractor keyExtractor);
}
public E pick();
public E poll();
public E update(int key, P prio);
public void remove(int key);
public interface KeyExtractor{
public int getKey(E e);
}
12

Fila-Queue
n
Operações abstratas:
n
n
n
n
inicialização;
colocação de um elemento na fila;
remoção de um elemento (FIFO);
indicar se fila está vazia.
n interface para uma fila :
public interface Queue{
public boolean isEmpty();
}
public boolean offer(E i);
public E poll();
public E remove();
public E peek();
Usando a mesma interface,
podem ser definidas várias
implementações!
Cátia Vaz
13

Fila (Queue) - inserção
14

Fila (Queue) - remoção
15

Implementação do tipo fila
usando um array
public class QueueArray implements Queue {
private E[] q;
private int size, head, tail;
public QueueArray(int maxN) { q=(E[])new Object[maxN]; }
public boolean isEmpty() { return size == 0 ;}
public boolean offer(E e){
if( size == q.length) return false;
q[tail] = e;
tail = (tail+1) % q.length; ++size;
return true;
}
public E remove() {
if(isEmpty()) throw new NoSuchElementException();
E e= q[head]; q[head]= null;
head= (head+1)%q.length; --size;
return e;
}
public E poll(){ return ( size == 0 ) ? null : remove();}
public E peek() {return ( size == 0 ) ? null : q[head]; }
}
16

Implementação do tipo fila
usando uma lista ligada
public class QueueList implements Queue {
private static class Node {
E item; Node next;
Node() { next=this; }
Node(E i, Node n) { item=i; next = n; }
}
private Node tail = new Node();
public boolean isEmpty() { return tail == tail.next; }
public boolean offer(E e){
tail.next = new Node( e, tail.next ); tail = tail.next;
return true;
}
public E remove() {
if(isEmpty()) throw new NoSuchElementException();
Node rem = tail.next.next; tail.next.next = rem.next;
if ( rem == tail ) tail = tail.next;
return rem.item;
}
public E poll() { return ( isEmpty() ) ? null : remove(); }
public E peek() { return ( isEmpty()) ? null :
tail.next.next.item; }
}
17

ADTs
§ ADTs permitem programação modular:
§ separam o programa em módulos mais pequenos;
§ clientes diferentes podem partilhar a mesma ADT.
§ ADTs permitem o encapsulamento:
§ mantêm-se os módulos independentes;
§ podem-se substituir as várias classes que implementam a
mesma interface, sem alterar o cliente.
§ Aspectos do desenho de uma ADT:
§ especificação formal do problema;
§ a implementação tem tendência a tornar-se obsoleta.
Cátia Vaz
18

Lista duplamente ligada
Inserção
19

Lista duplamente ligada
Pesquisa
20

Lista duplamente ligada
Remoção
21

Lista Duplamente Ligada
public interface DList extends Iterable{
public int size();
public boolean isEmpty();
public void add(E e);
public boolean remove(E e);
}
Cátia Vaz
22

Iteradores
public interface Iterable {
public Iterator iterator();
}
public interface Iterator {
public boolean hasNext();
public E next();
public void remove();
}
Cátia Vaz
23

Lista Duplamente Ligada
public class DLinkedList1 implements DList {
private static class DNode {
public DNode next, prev;
public T key;
public DNode() { }
public DNode(T e ) { key=e; }
}
protected int size;
protected DNode head;
public int size() { return size;}
public boolean isEmpty(){ return head == null;}
public void add(E e) { // Adiciona o elemento no inicio da lista ligada
DNode n=new DNode(e);
if(head!=null){ n.next=head; head.prev=n;}
head=n; }
//(continua...)
}
Cátia Vaz
24

Lista Duplamente Ligada
public class DLinkedList1 implements DList {
//(continuação...)
// Remove o primeiro elemento da lista igual a e
public boolean remove (E e){
DNode aux=search(e);
if(aux!=null){
if(aux.prev != null) {aux.prev.next = aux.next;}
else{head = aux.next;}
if(aux.next != null){ aux.next.prev = aux.prev;}
return true;
}
else return false;
}
protected DNode search( E e ){
DNode aux = head;
while( aux != null && !aux.key.equals(e))
aux=aux.next;
return aux;
}
//(continua...)
}
Cátia Vaz
25

Lista Duplamente Ligada
public class DLinkedList1 implements DList {
//(continuação...)
public static void show(DNode l){
System.out.print("< ");
while(l != null){ System.out.print(l.key+" "); l = l.next;}
System.out.println(">");
}
public void reverse() {
DNode iter = head, aux;
while( iter != null ) {
head = iter;
aux = iter.next;
iter.next = iter.prev;
iter.prev = aux;
iter = aux;
}
}
//(continua...)
}
Cátia Vaz
26

Lista Duplamente Ligada-
Iteradores
public class DLinkedList1 implements DList {
//(continuação...)
private class LinkedIterator implements Iterator {
// Nó dos dados retornados pelo next() seguinte.
protected DNode node = head;
/* Nó retornado pelo next() anterior. Como inicialmente não existiu next() referecia
null. Depois de um remove() permite assinalar que não existe next() anterior.*/
protected DNode prev = null;
// Retorna true se existem mais elementos para iterar.
public boolean hasNext() { return node != null; }
// Retorna o elemento da posição corrente e avança.
public E next() {
if ( node == null )throw new NoSuchElementException();
prev = node; node = node.next; // Avança
return prev.key;
}
//(continua...)
}
Cátia Vaz
27

Lista Duplamente Ligada-
Iteradores
public class DLinkedList1 implements DList {
//(continuação...)
public void remove() {
// Se a última operação não foi next() lança excepção
if ( prev == null ) throw new IllegalStateException();
// Remove o nó do elemnto retornado pelo último next
DLinkedList1.this.remove(prev);
prev = null; // Assinala que a operação anterior não foi um next()
}
}//termina a classe LinkedIterator
public Iterator iterator() {return new LinkedIterator(); }
protected void remove( DNode rem ){
if ( rem.next != null) rem.next.prev=rem.prev;
if ( rem.prev != null )
rem.prev.next=rem.next;
else
head = rem.next;
--size;
}
//(...)
}
Cátia Vaz
28

Lista com sentinela
Inserção
29

Lista com sentinela
Remoção
30

Lista com sentinela
Pesquisa
31

Lista Duplamente Ligada
public interface DCList{
public int size();
public boolean isEmpty();
}
public void add(E e);
public boolean remove(E e);
Cátia Vaz
32

Lista Duplamente Ligada com
Sentinela e Circular
public class DLinkedList3 implements DCList{
private static class DNode {
public DNode next, prev;
public E key;
public DNode() { }
public DNode(E e ) { key=e; }
}
private int size;
protected DNode dummy;
public DLinkedList3() {
dummy=new DNode(); dummy.next= dummy.prev = dummy;}
public int size()
{ return size;}
public boolean isEmpty() { return dummy.next == dummy;}
//(continua...)
}
Cátia Vaz
33

Lista Duplamente Ligada com
Sentinela e Circular
public class DLinkedList3 implements DCList {
//(continuação...)
public E getFirst() { return dummy.next.key; }
public E getLast() { return dummy.prev.key; }
// Adiciona o elemento no fim da lista ligada
public void add(E e) {
DNode n=new DNode(e); ++size;
n.prev=dummy.prev;
n.next=dummy;
dummy.prev.next=n;
dummy.prev=n;
}
public boolean remove(E e){
DNode aux=search(e);
if(aux!=null){
aux.next.prev=aux.prev; aux.prev.next=aux.next; return true;}
return false;
}
//(continua..)
}
Cátia Vaz
34

Lista Duplamente Ligada com
Sentinela e Circular
public class DLinkedList3 implements DCList {
//(continuação...)
public DNode search(E e){
DNode aux=dummy.next;
while(aux!=dummy){
if(aux.key.equals(e)){ return aux;}
aux=aux.next;
}
return null;
}
//(continua...)
}
Cátia Vaz
35

Lista Duplamente Ligada com
Sentinela e Circular
public class DLinkedList3 implements DCList {
//(...)/*Move os nós da lista 2 para a lista 1. Assume que as duas listas estão ordenadas
*pela ordem dada pelo comparador. A lista 1 permanece ordenada e a lista 2 fica vazia.*/
public static < E > DNode merge( DNode dummy1, DNode dummy2,
Comparator cmp) {
DNode head1 = dummy1.next; DNode head2 = dummy2.next;
while (head1 != dummy1 && head2 != dummy2 ) {
if ( cmp.compare( head1.key, head2.key)

Lista Duplamente Ligada com
Sentinela e Circular
public class DLinkedList3 implements DList{
//(...)/*Move os nós da lista 2 para a lista 1. Assume que as duas listas estão ordenadas
*pela ordem dada pelo comparador. A lista 1 permanece ordenada e a lista 2 fica vazia.*/
public static < E > DNode merge( DNode dummy1, DNode dummy2,
Comparator cmp) {
DNode head1 = dummy1.next; DNode head2 = dummy2.next;
while (head1 != dummy1 && head2 != dummy2 ) {
if ( cmp.compare( head1.key, head2.key)

Exercício
n Implementar o algoritmo merge sort para
duas listas duplamente ligadas.
☺
Cátia Vaz
38