if969 - estrutura de dados: pilhas e filas

Estrutura de Dados: Pilhas e Filas Centro de Informá-ca Universidade Federal de Pernambuco Sistemas de Informação Vinicius Cardoso Garcia [email protected]

© 2011 – Vinicius Cardoso Garcia

Pilhas •  Uma pilha é uma coleção de objetos que são inseridos e re-rados de acordo com o princípio que o úl(mo que entra é o primeiro que sai (LIFO)

•  Pode-‐se inserir um objeto a qualquer momento, mas somente o objeto inserido recentemente pode ser removido a qualquer momento

Algoritmos e Estrutura de Dados Estrutura de Dados: Pilhas e Filas © 2011 – Vinicius Cardoso Garcia

2

Pergunta: Onde pilhas são usadas? •  Em computação, que situações vocês lembram de verem pilhas sendo usadas?


3

Tipo Abstrato de Dados: Pilha •  As mais simples de todas as estruturas de dados •  Formalmente, uma pilha S é um -po abstrato de dados (TAD) que suporta os métodos –  push(e): insere o objeto e no topo da pilha –  pop(): re-ra o objeto do topo da pilha e o retorna; ocorre um erro se a pilha es-ver vazia

–  size(): retorna o número de elementos na pilha –  isEmpty(): retorna um booleano indicando se a pilha está vazia

–  top(): retorna o elemento no topo da pilha, sem re-rá-‐lo; ocorre um erro se a pilha es-ver vazia


4

Exemplo: Uma pilha P

P

1

2

3

4

5

15

6

2

9

6 A pilha P possui 4 elementos O elemento do topo (S[4]) é 9


5

Inserção na pilha P A inserção em uma pilha é feita através de uma operação chamada PUSH P = (15, 6, 2, 9) top[P] = 4 Vamos ver como fica a pilha após duas operações de inserção:

PUSH(P, 17) PUSH(P, 3)

1

2

3

4

5

15

6

2

9

6

P


6

Inserindo na Pilha: PUSH(P,17)

P = (15, 6, 2, 9) PUSH(P, 17) P = (15, 6, 2, 9, 17) top[P] = 5 17

1

2

3

4

5

15

6

2

9

6

P


7

Inserindo na Pilha: PUSH(P,3)

P = (15, 6, 2, 9, 17) PUSH(P, 3) P = (15, 6, 2, 9, 17, 3) top[P] = 6 17

1

2

3

4

5

15

6

2

9

3 6

P


8

Removendo da Pilha: POP(P)

P = (15, 6, 2, 9, 17, 3) POP(P) P = (15, 6, 2, 9, 17) top[P] = 5 17

1

2

3

4

5

15

6

2

9

6

P


9

Pré-‐condições para as operações •  PUSH:

– A pilha deve possuir espaços disponíveis para a inserção de um novo item

•  POP – A pilha não pode estar vazia


10

Implementação baseada em arranjos •  Um arranjo S de N

elementos mais uma variável inteira t que fornece o índice do elemento no topo do arranjo S.

•  Índices em Java começam com 0, t = -‐1 (pilha vazia)

•  Quan-dade de elementos :: t + 1

11

S 0 1 2 t

…

Algorithm size() return t + 1

Algorithm pop() if isEmpty() then throw EmptyStackException else t ← t - 1 return S[t + 1]


Implementação baseada em arranjos •  O arranjo que armazena os elementos da pilha pode ficar cheio

•  A operação de push vai lançar uma nova exceção –  FullStackExcep(on

•  Limitação da implementação baseada em arranjo


12

S 0 1 2 t

…

Algorithm push(o) if t = S.length - 1 then throw FullStackException else t ← t + 1 S[t] ← o

Problema •  Implementação baseada em arranjo é simples e eficiente

•  Qual o aspecto nega-vo?

•  Qual seria uma solução aceitável?


13

Implementando uma Pilha com LSEs •  Primeiro passo: onde será o topo da pilha, na cabeça ou na cauda –  Inserir e remover elementos constantemente apenas na cabeça

– Variável de instância para o número corrente de elementos (size)


14

Exemplo: Verificando parênteses •  Verificação de parênteses e o agrupamento de símbolos aritmé-cos

•  Para cada símbolo de abertura deve corresponder um símbolo de fechamento – correto: ( )(( )){([( )])} – correto: ((( )(( )){([( )])} –  incorreto: )(( )){([( )])} –  incorreto: ({[ ])} –  incorreto: (


15

Verificando parênteses: Algoritmo


16

Algorithm ParenMatch(X,n): Input: An array X of n tokens, each of which is either a grouping symbol, a variable, an arithmetic operator, or a number Output: true if and only if all the grouping symbols in X match Let S be an empty stack for i=0 to n-1 do

if X[i] is an opening grouping symbol then S.push(X[i]) else if X[i] is a closing grouping symbol then if S.isEmpty() then return false {nothing to match with} if S.pop() does not match the type of X[i] then return false {wrong type}

if S.isEmpty() then return true {every symbol matched}

else return false {some symbols were never matched}

FILAS


17

Filas •  Coleção de objetos que são inseridos e removidos de acordo com o princípio de que o primeiro que entra é o primeiro que sai (FIFO)

•  Pode-‐se inserir os elementos em qualquer momento, mas somente o elemento que está na fila a mais tempo pode ser re-rado em um dado momento


18

Tipo abstrato de dados: Fila •  Remoção no início, inserção no fim •  Principais operações

– enqueue(o): insere o elemento e no fim da fila – dequeue(): re-ra e retorna o objeto da frente da fila; ocorre um erro se a fila es-ver vazia

– size(): reorna o número de objetos na fila –  isEmpty(): retorna um booleano indicando se a fila está vazia

–  front(): retorna, mas não remove, o objeto na frente da fila; ocorre um erro se a fila es-ver vazia


19

Filas -‐ Exemplo

F 1 2 3 4 5 6

A fila F possui 5 elementos O elemento do início (F[7]) é o 15 As primeiras operações de exemplo são: ENQUEUE(F, 17) ENQUEUE(F, 3) ENQUEUE(F, 5) DEQUEUE()

15 6 8 9

7 8 9 10 11 12

4

inicio[F] = 7 fim[F] = 12


20

Fila – Exemplo: ENQUEUE(F, 17)

F 1 2 3 4 5 6

15 6 8 9

7 8 9 10 11 12

4


17


21


F 1 2 3 4 5 6

15 6 8 9

7 8 9 10 11 12

4


17 3


22


F 1 2 3 4 5 6

15 6 8 9

7 8 9 10 11 12

4


17 3 5


23

Fila – Exemplo: DEQUEUE()

F 1 2 3 4 5 6

6 8 9

7 8 9 10 11 12

4


17 3 5


24

Implementação baseada em arranjos •  Usando arranjo de maneira circular

– Para evitar mover objetos armazenados em Q •  f: índice para o primeiro elemento •  r: índice para próxima posição livre de Q •  Inicialmente f = r = 0

Q

0 1 2 r f

normal configura-on

Q

0 1 2 f r

wrapped-‐around configura-on


25

Usando o módulo operador

•  Cada vez que incrementar f ou r –  (f +1) mod N –  (r + 1) mod N

•  Quando f = r (fila cheia), é a mesma situação da fila vazia –  Q não pode ter no máximo N-‐1 objetos


26


•  Uso do módulo operador Algorithm size()

return (N - f + r) mod N Algorithm isEmpty() return (f = r)

Q

0 1 2 r f

Q

0 1 2 f r


27


•  A operação enqueue lança uma exceção se o arranjo está cheio

•  Exceção dependente de implementação

Algorithm enqueue(o) if size() = N - 1 then throw FullQueueException else Q[r] ← o r ← (r + 1) mod N

Q

0 1 2 r f

Q

0 1 2 f r


28


•  A operação dequeue lança uma exceção se a fila está vazio

•  Exceção especificada no TAD

Q

0 1 2 r f

Q

0 1 2 f r

Algorithm dequeue() if isEmpty() then throw EmptyQueueException else o ← Q[f] f ← (f + 1) mod N return o


29

AXvidades Complementares •  Solucionar os exercícios propostos nos próximos slides

•  Desafio: O Problema de Josephus

•  Leitura do capítulo 10 do Cormen


30

Desafio: O Problema de Josephus •  Batata quente

– Grupo de N crianças em círculo passa a batata em volta do círculo

– Ao toque do sino, a criança que es-ver com a batata na mão, sai do jogo e deixa a batata com a próxima criança

– Con-nua até restar uma criança – Sinto toca após a batata ter sido passada k vezes, para algum valor fixo de k


31

Exercícios de Pilha •  1. Ilustre o resultado de cada operação na sequência: PUSH(P, 4), PUSH(P, 3), POP(P), PUSH(P, 8) e POP(P) sobre uma pilha P inicialmente vazia armazenada em um vetor P[1..6]

•  2. Para a mesma pilha vazia, ilustre as seguintes sequências: – PUSH(P, 3), POP(P), POP(P), PUSH(P, 4) – PUSH(P, 1), POP(P), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1)


32

Exercícios de Pilha •  3. Implemente uma pilha na linguagem de programação de sua preferência e rodem as seguintes configurações de pilhas: –  Ilustre o resultado de cada operação na sequência: PUSH(P, 4), PUSH(P, 3), POP(P), PUSH(S, 8) e POP(P) sobre uma pilha P inicialmente vazia armazenada em um vetor P[1..6]

–  Para a mesma pilha vazia, ilustre as seguintes sequências:

•  PUSH(P, 3), POP(P), POP(P), PUSH(P, 4) •  PUSH(P, 1), POP(P), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1), PUSH(P, 1)


33

Exercícios de Pilha •  4. Adicione uma restrição para que a pilha seja criada com uma capacidade máxima (em seu tamanho). Mostre os algoritmos e a implementação modificada.

•  5. Especifique e implemente operações para: – Retornar o número de objetos na pilha – Retornar o objeto no topo da pilha, sem removê-‐lo (deve retornar um erro caso a pilha esteja vazia)


34

Exercícios •  6. Seja a função esvazie( ) tal que, recebendo uma pilha

como entrada, esvazie a pilha descartando todos os seus elementos. Escreva a função esvazie( )

•  7. Escreva um programa que verifique que expressões aritmé-cas estão com os parênteses colocados de forma correta. Guarde o resultado numa pilha também. Seu programa deve checar expressões para ver se cada "abre parênteses" tem um "fecha parênteses" correspondente.

•  8. Uma palavra é uma palíndrome se a seqüência de letras que a forma é a mesma seja ela lida da esquerda para a direita ou vice-‐versa. Exemplos: arara, rairar, hanah. Escreva a função palíndrome que, dada uma palavra, retorne true caso a palavra seja uma palíndrome, e false caso contrário. Use uma pilha para tal.


35

Exercício •  9. Implementar um algoritmo para o problema das torres de hanoi – Resumidamente, as regras são:

•  Movimentar uma só peça de cada vez •  Uma peça maior não pode ficar acima de uma menor •  Não é permi-do movimentar uma peça que esteja abaixo de outra

– Mais detalhes em: •  hwp://pt.wikipedia.org/wiki/Torre_de_Hanoi


36

Exercícios de Filas •  1. Descreva a saída da seguinte sequência de operações sobre uma fila: ENQUEUE(5), ENQUEUE(3), DEQUEUE() , ENQUEUE(2), ENQUEUE(8), DEQUEUE() , DEQUEUE() ENQUEUE(9), ENQUEUE(1), DEQUEUE(), ENQUEUE(7), ENQUEUE(6), DEQUEUE() DEQUEUE(), ENQUEUE(4), DEQUEUE() DEQUEUE()


37

Exercícios de Filas •  2. Implemente uma fila na linguagem de programação de sua preferência e rodem as seguintes configurações: –  Ilustre o resultado de cada operação na sequência do exercício anterior

•  3. Modifique os algoritmos de forma que eles detectem problemas de estouro na fila (fila sem espaço para serem inseridos novos elementos) e problemas de tenta-vas de remoção em filas vazias


38

Exercícios de Filas •  4. Modifique os algoritmos de fila de forma que os elementos sejam movimentados para a frente da fila quando o elemento do início for removido (a fila “anda” quando um el. é desenfileirado)


39

if969 - estrutura de dados: pilhas e filas

Documents