Algoritmos Aula 6 Estrutura de Repetição Prof. Luiz [email protected].
Estrutura de dados Pilhas e filas PROFESSOR LUIZ JOSE HOFFMANN FILHO [email protected].
30
-
Upload
natan-pacheco-barreiro -
Category
Documents
-
view
227 -
download
0
Transcript of Estrutura de dados Pilhas e filas PROFESSOR LUIZ JOSE HOFFMANN FILHO [email protected].
Estrutura de dadosPilhas e filasPROFESSOR LUIZ JOSE HOFFMANN [email protected]
Pilhas Uma pilha é uma coleção de objetos que são inseridos e retirados de acordo com o princípio que o último 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
Pergunta: Onde pilhas são usadas?
Em computação, que situações vocês lembram de verem pilhas sendo usadas?
Tipo Abstrato de Dados: Pilha
As mais simples de todas as estruturas de dados
Formalmente, um pilha S é um tipo abstrato de dados (TAD) que suporta os métodos
◦ Push(e): insere o objeto e no topo da pilha◦ Pop(): retira o objeto do topo da pilha e o retorna; ocorre um erro se a pilha
estiver 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 retira-lo; ocorre um erro se
a pilha estiver vazia
Exemplo: Uma pilha P A pilha P possui 4 elementos
O elemento do tipo (P[4]) é 9
9
2
6
151
2
3
4
5
6
P
Inserção na pilha P A inserção em uma pilha é feita através de uma operação de 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)
9
2
6
151
2
3
4
5
6
P
Inserção na pilha PUSH(P, 17)
P = (15, 6, 2, 9)
PUSH(P, 17)
P = (15, 6, 2, 9, 17)
Top[P] = 5
17
9
2
6
151
2
3
4
5
6
P
Inserção na pilha PUSH(P, 3)
P = (15, 6, 2, 9, 17)
PUSH(P, 3)
P = (15, 6, 2, 9, 17, 3)
Top[P] = 6
3
17
9
2
6
151
2
3
4
5
6
P
Removendo da pilha POP(P)
P = (15, 6, 2, 9, 17, 3)
POP(P,)
P = (15, 6, 2, 9, 17)
Top[P] = 5
17
9
2
6
151
2
3
4
5
6
P
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
Implementação baseada em vetor
Um vetor S de N elementos mais uma variável inteira T que fornece o índice do elemento no topo do vetor S.
Índices em C começam com 0, T = -1 (pilha vazia)
Quantidade de elementos :: T + 1
Int Size() {Return t +1;
}
Int pop() {
if isEmpty() {
return 0;
} else {
t = t -1;
return S[t -1];
}
Implementação baseada em vetor
O vetor que armazena os elementos da pilha pode ficar cheio
A operação de push vai lançar uma nova exceção – limitação da implementação baseada em vetor
Int push(int valor) {
if (t ==(tamanho-1)) {
return 0;
} else {
t = t +1;
S[t] = valor;
}
Problema Implementação baseada em vetor é simples e eficiente
Qual o aspecto negativo?
Qual seria uma solução aceitável?
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)
Filas
Filas Coleçãp 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 retirado em um dado momento
Tipo abstrato de dados: Fila
Remoção no início, inserção no fim
Principais operações◦ Enqueue(o): insere o lemento o no fim da fila◦ Dequeue(): retira e retorna o objeto da frente da fila; ocorre um erro se a fila
estiver vazia◦ Size(): retorna o número de objetos na fila◦ isEmpty(): retorna um booleano indicando se a fila estáo vazia◦ front(): retorna, mas não remove, o objeto na frente da fila; ocorre um erro
se a fila estiver vazia
Fila - Exemplo
A fila F possui 5 elementos
O elemento do início (F[7]) é o 15
As primeira operações de exemplo são:◦ ENQUEUE(F, 17)◦ ENQUEUE(F, 3)◦ ENQUEUE(F, 5)◦ ENQUEUE()
15 6 9 4F
1 2 3 4 5 6 7 8 9 10
Inicio[F]= 6 Fim[F] = 10
Fila – Exemplo:ENQUEUE(F, 17)
15 6 9 4 17F
1 2 3 4 5 6 7 8 9 10
Inicio[F]= 6Fim[F] = 1
Fila – Exemplo:ENQUEUE(F, 3)
3 15 6 9 4 17F
1 2 3 4 5 6 7 8 9 10
Inicio[F]= 6Fim[F] = 2
Fila – Exemplo:DEQUEUE()
3 6 9 4 17F
1 2 3 4 5 6 7 8 9 10
Inicio[F]= 7Fim[F] = 2
Usando o módulo operador
A operação enqueue lança uma exceção se o vetor está cheio
Exceção dependente de implementação
Int enqueue(o) {
if (size()= N-1) {
return -1;
} else {
Q[r] = o;
r = (r +1 ) mod N
}
}
Usando o módulo operador
A operação dequeue lança uma exceção se a fila está vazia
Exceção especificada no TAD
Int dequeue() {
if idEmpty() {
return –1;
} else {
o = Q[f];
f = (f +1) % N;
return o;
}
}
Exercício de Pilha 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 a 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)
Exercício de pilha Implemente uma pilha em C e rodem as seguintes condigurações de pilhas:
◦ 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 um pilha P inicialmente vazia armazenada em uma lista encadeada
◦ Para a mesma pilha vazia, ilusre 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)
Exercício de Pilha Especifique e implemente operações para:
◦ Retornar o número de elementos na pilha◦ Retornar o elemento no topo da pilha, sem removê-lo (deve retornar um
erro caso a pilha esteja vazia)
Seja a função esvazie() tal que, recebendo uma pilha como entrada, esvazie a pilha e descartando todos os seus elementos. Escreva a função esvazie();
Exercícios Escreva um programa que verifique que expressões aritméticas estão com os parêmeteses 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.
Exercícios de Filas 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()
Exercícios de Filas Implemente uma fila em C e rodem as seguintes configurações:
◦ Ilustre o resultado de cada operação na sequência do exercício anterior
Modifique os algoritmos de forma que eles dectem problemas de estouro de fila (fila sem espaço para serem inseridos novos elementos) e problemas de tentativas de remoção em filas vazias;
Exercícios de Filas Modifique os algoritmos de fila de forma que os elementos sejam movimentados para a frente de fila quando o elemento do início for removido (a fila “anda” quando um elemento é desenfileirado)
