Pilha Fila Estatica

7/24/2019 Pilha Fila Estatica

1/36

Tipos Especiais de Listas

Pilha

Fila


2/36

2

Tipos especiais de listas

O armazenamento seqencial (esttico) til quando

as estruturas sofrem poucas remoesouinseres ou ainda quando inseres e remoesno acarretam grande movimentao de ns No bem o caso da implementao de lista que permite

remover e inserir um elemento em qualquer posio da

lista... Por isso, o armazenamento seqencial mais usado para

implementar os tipos especiais de listas:

Filas (Queue em ingls),

Pilhas (Stack em ingls) e

Deques (Deque em ingls) So mais ferramentas do programador do que estruturas de

armazenamento.


3/36

Pilha

(Stack)


4/36

4

Pilhas (stack)

Os elementos so inseridos e removidos sempre em umaextremidade (a final) chamada de topo da pilha.

Contm um ponteiro (varivel) que marca o topo da pilha.

Implementa norma: LIFO(last-in, first-out) ltimo a entrar, primeiro a sair.

Pilha Vazia: topo=-1

5

4

32

1

0 17

push (17)Insero de 17 no topo da pilha

topo


5/36

Pilhas (Stack)

Operaes sobre Pilhas:

Verificar se a pilha est vazia

Verificar se a pilha est cheia

Inserir um elemento no topo da pilhaRemover um elemento do topo da pilhaInspecionar o elemento do topo da pilha


6/36

6

Pilhas

5

4

32

1

0 17

push (17)Insero de 17 no topo da pilha

top


7/36

7

5

43

2

1

0 17

push(5)

Insero de 5 no topo da pilha

5

5

4

32

1

0 17

pop()Remoo (sempre no topo da pilha)

top

top


8/36

8

5

43

2

1

0 17

push(123)

Insero de 123 no topo da pilha

123

5

4

3

2

1

0 17

push(25)Insero de 25 no topo da pilha

123

25

top

top


9/36

9

5

43

2

1

0 17

push(12)Insero de 12 no topo da pilha

123

5

4

3

2

1

0 17

pop()Remoo (sempre no topo da pilha)

123

25

25

12 top

top


10/36

10

Estouro de pilhas: Estouro negativo (underflow): pilha vazia sofre

operao de extrao

Estouro positivo (overflow): quando a insero de umelemento excede a capacidade total da pilha.


11/36

11

Interface Stack

publicinterfaceStack {

/** Return the number of elements in the stack. */publicintnumElements();

/** Return whether the stack is empty. */publicbooleanisEmpty();

/** Return whether the stack is full. */publicbooleanisFull();

/** Inspect the element at the top of the stack.*/publicE top() throwsEmptyStackException;

/**Insert an element at the top of the stack.*/

publicvoidpush (E element);

/** Remove the top element from the stack.*/publicE pop() throwsEmptyStackException;

}


12/36

12

Classe StaticStack

publicclassStaticStack implementsStack {

// ndice do elemento no topo da pilhaprotectedinttop;

// Array que armazena as referncias para os elementosprotectedE elements[];

// Constroi uma pilha com um tamanho mximopublicStaticStack(int maxSize) {

elements= (E[])newObject[maxSize];top= -1;

}


13/36

Classe StaticStack (cont.)

/**Returns the number of elements in the stack. */publicintnumElements() {return(top+ 1);

}

/**Testes whether the stack is empty. */publicbooleanisEmpty() {returntop== -1;

}

/**Testes whether the stack is full. */public boolean isFull() {returntop== elements.length 1;

}


14/36

14

/**Inserts an element at the top of the stack. */publicvoidpush(E element) throwsOverflowException {

if(isFull())thrownewOverflowException();

elements[++top] = element;}

/** Inspects the element at the top of the stack. */publicE top() throws UnderflowException {if(isEmpty())thrownewUnderflowException();

returnelements[top];

}



15/36

15


/**Removes the top element from the stack. */

publicE pop() throwsUnderflowException {if(isEmpty())thrownewUnderflowException ();

E element = elements[top];elements [top--] = null; // para a coleta de lixo.returnelement;

}}


16/36


/*** Returns a string representation of the stack as a list of

elements.*/publicString toString() {

if(isEmpty())

return [Empty] ;

else{

String s = "[";for(inti = numElements() - 1; i >= 0; i--) {

s += "\n"+ elements[i];}s+= "\n"+ "]"+ "\n";

returns;

}}

16


17/36

Testando a Pilha

17

publicclassStaticStackTest {publicstaticvoidmain(String[] args) {

StaticStack s = newStaticStack(10);

try{ s.push(1);s.push(2);s.push(3);s.push(4);s.push(5);

} catch(UnderflowExceptione) {

System.out.println(e);}

try{while(!s.isEmpty()) {

System.out.println(s.pop());}

}catch(UnderflowExceptione){System.out.println(e);

}}

}


18/36

Exerccio

18

Implemente um mtodo que inverta o contedo de uma pilha passadacomo parmetro. Para isso considere a seguinte assinatura:

public void invertePilha(Stack s)


19/36

Fila(Queue)


20/36

20

Filas (Queue)

Elementos so inseridos no fim da fila e retirados do incio da fila.

Geralmente, a implementao, contm 2 ponteiros (variveis):

Um ponteiro para o incio da fila (first) Um ponteiro para o fim da fila (last)

FIFO(first-int, first-out)

primeiro a entrar, primeiro a sair

Fila vazia:

Quando last==first-1;

Underflow: fila vazia sofreoperao de extrao

Overflow: quando a insero deum elemento excede acapacidade total da fila.

1 2 3 4 5 6 7


21/36

Operaes sobre Filas (Queue)

Verificar se a fila est vazia

Inserir um elemento no final da fila

Remover e retornar o elemento do inicioda fila

Consultar o elemento do inicio da fila

Obter o tamanho da fila


22/36

22

Operaes da Fila

0 1 2 3 4 5

fila vaziafirst==-1

0 1 2 3 4 5

90 12 117

fila cheiafirst==0 &&last==v.length-1

first last

8 6

0 1 2 3 4 5

7

first

last

0 1 2 3 4 5

907 8 6

first last

0 1 2 3 4 5

90 12 117

firstlast

0 1 2 3 4 5

4 12 113

fila cheiafirst==last+1

firstlast

5 6


23/36

Fila com implementao circular

0 1 2 3 4 5

incio da filafim da fila

90 12 117


24/36

24

Interface Queue

publicinterfaceQueue {/** Returns the number of elements in the queue.*/

publicintnumElements();/** Returns whether the queue is empty. */publicbooleanisEmpty();/** Returns whether the queue is full. */public boolean isFull();/** Inspects the element at the front of the queue.*/publicE front() throwsUnderflowException;/** Inspects the element at the back of the queue.*/public E back() throws UnderflowException;/** Inserts an element at the rear of the queue. */publicvoidenqueue (E element) throws OverflowException;

/** Removes the element at the front of the queue.*/publicE dequeue() throwsUnderflowException;

}


25/36

25

Classe StaticQueue

publicclassStaticQueue implementsQueue{

//Index to the first elementprotectedintfirst;

//Index to the last element

protectedintlast;

// Generic array used to store the elementsprotectedE elements[];

publicStaticQueue(intmaxSize) {elements= (E[]) newObject[maxSize];

first= last= -1;}


26/36

26

Classe StaticQueue (cont.)

/** Testes whether the queue is empty. */publicbooleanisEmpty() {

return first == -1;}

publicbooleanisFull() {returnfirst== ((last+ 1) % elements.length);

}

/** Returns the number of elements in the queue. */publicintnumElements() {

if (isEmpty())return 0;

else {int n = elements.length;

return ((n + last first) % n) + 1;

}}


27/36

27


/** Inspects the element at the front of the queue.*/publicE front() throwsUnderflowException {if(isEmpty())

thrownewUnderflowException ();returnelements[first];

}

/** Inspects the element at the back of the queue.*/publicE back() throwsUnderflowException {

if(isEmpty())thrownewUnderflowException ();

returnelements[last];

}


28/36

28


/** Inserts an element at the rear of the queue. */publicvoidenqueue(E element) throwsOverflowException {

if(isFull())thrownewOverflowException();

else{

if(last== -1)first= last= 0;

elselast= (last+ 1) % elements.length;

elements[last] = element;}

}


29/36

29


/** Removes and return the element at the front of the queue.*/publicE dequeue() throwsUnderflowException {

if(isEmpty())thrownewUnderflowException();

E element = elements[first];elements[first] = null; // p/ coleta de lixo

if(first== last)first= last= -1;else

first= (first+ 1) % elements.length;

returnelement;}

Testando a Fila


30/36

30

Testando a Fila

publicclassStaticQueueTest {publicstaticvoidmain(String[] args) {

StaticQueue q = newStaticQueue(5);try{

q.enqueue(1);q.enqueue(2);q.enqueue(3);q.enqueue(4);

q.dequeue();q.dequeue();

q.enqueue(5);q.enqueue(6);q.enqueue(7);

} catch(OverflowException e) {System.out.println(e);

}catch(UnderflowException e) {

System.out.println(e);}

}}

i


31/36

Exerccio

Implemente mtodos para exibir o contedo da filacircular de 2 maneiras:1.

No mtodo main, faa o cdigo necessrio para queenquanto a fila no for vazia, esvazie a fila, exibindo oselementos retirados.

2. Crie um mtodo toString() na classe StaticQueue queretorne uma String com o contedo da fila na ordem emque foram inseridos

E i


32/36

Exerccios

Dada 2 pilhas ordenadas deelementos a partir do topo,escreva o cdigo necessrio paraque o contedo das pilhas sejaminserido em uma terceira pilha deforma tambm ordenada. O

contedo das pilhas iniciais podeser removido.

32

E i


33/36

Exerccios

33

E i


34/36

Exerccios

Uma palavra um palndromose tem a mesmaseqncia de letras, quer seja lida da esquerda paraa direita ou da direita para a esquerda (exemplo:raiar). Escrever pelo menos 2 algoritmos paraverificar se uma palavra um palndromo, usandopilha(s) e/ou fila(s). Compare esses algoritmos do

ponto de vista de eficincia e consumo de memria.

34

E i


35/36

Exerccios

Escreva um procedimento para inverter a ordem doselementos de uma fila, usando uma pilha comoestrutura auxiliar.

35

E i


36/36

Exerccios

36

A estrutura de dados conhecida como Deque (do ingls

double queue) permite a insero e remoo de elementosapenas nas extremidades.

Com isso em mente implemente a classe StaticDeque. Estaclasse deve utilizar um vetor como estrutura dearmazenamento e deve permitir inseres e remoes

apenas nas extremidades (inicio e fim).

Pilha Fila Estatica

Documents

Transcript of Pilha Fila Estatica