ESTRUTURA DE DADOS (TCC )

Transcrição

1 ESTRUTURA DE DADOS (TCC ) Listas lineares Pilhas e Filas Cristina Boeres

2 2 Manipulando listas lineares! Dependendo do problema a ser resolvidos, existem duas formas especiais (que veremos aqui no curso) de acessar os elementos de uma lista linear:! pilha! fila! São as chamadas estruturas de acesso restrito

3 Estruturas de Acesso Restrito! Motivo: para muitas aplicações é necessário impor restrições de acesso aos dados! essas restrições podem vir a ser benéficas por:! aliviar a necessidade de usar estruturas com mais detalhes! permitem implementações mais simples e flexíveis, desde que menos operações são suportadas! pilhas: LIFO - last in first out! filas: FIFO - first in first out 3

4 Pilha! Apenas duas operácões básicas estão envolvidas:! PUSH ou Empilha: Acrescentar no topo da pilha! POP ou Desempilha: Retirar do topo da pilha o elem. 3 o elem. 2 o elem. 1 o elem. 3 o elem. 2 o elem. 1 o elem. 3 o elem. 2 o elem. 1 o elem.

5 Pilhas! A política de inserção e remoção à maneira de uma pilha é também conhecida como LIFO: Last In, First Out 5

6 Pilhas em Lista Sequenciais! PILHA[] lista sequencial que implementa pilha! há necessidade de especificar um índice que indica o topo da pilha! indica qual a posição por onde as operações de inclusão e remoção (e até consulta) serão realizadas! o elemento 0 será definido como o fundo da pilha! Encontramos a definição de duas formas:! TOPO aponta para a próxima posição livre na pilha! TOPO aponta para o último elemento incluído 6

7 Pilhas em Lista Sequenciais! PILHA - lista sequencial que implementa pilha! TOPO aponta para a próxima posição livre na pilha! pilha vazia: TOPO = 0! TOPO aponta para o último elemento incluído 2 1 0! pilha vazia: TOPO = ! De qualquer forma há a restrição do tamanho máximo da lista alocada 7

8 Pilhas em Lista Sequenciais! PILHA - lista sequencial que implementa pilha! TOPO indica a 1 a posição livre de PILHA 5 elemento elemento 3 elemento 2 elemento

9 Pilhas - Lista Sequenciais! PILHA - lista sequencial com PMAX elementos. Suponha que seja uma lista de inteiros. Então: #define PMAX 1000 int PILHA[PMAX]; int Topo;! Assim, para inicializar a pilha: iniciapilha(){ } Topo = 0 /* Pilha vazia */ 9

10 Inclusão na pilha! a inclusão ou empilhamento! realizada em um extremo! Topo já indica a posição do novo elemento a ser incluído! é só atualizar Topo após a inclusão! Importante: verificar se tem espaço para incluir 10

11 Inclusão na pilha empilha (x) /* Só podemos empilhar se existe espaço já alocado */ if(topo < PMAX) { PILHA[topo] = x; Topo++; return(true); } else return(false); /* estouro da pilha */ elemento elemento elemento 2 elemento

12 Inclusão na pilha empilha (x) /* Só podemos empilhar se existe espaço já alocado */ if(topo < PMAX) { PILHA[topo] = x; Topo++; return(true); } else return(false); /* estouro da pilha */ x elemento elemento elemento 2 elemento

13 Inclusão na pilha empilha (x) /* Só podemos empilhar se existe espaço já alocado */ if(topo < PMAX) { PILHA[topo] = x; Topo++; return(true); } else return(false); /* estouro da pilha */ x elemento elemento elemento 2 elemento

14 Remoção na pilha! a remoção ou desempilhamento! realizada na mesma extremidade! está na posição indicada por Topo! Importante: verificar se não está tentando desempilhar da PILHA vazia 1

15 Remoção na pilha #define VAZIA desempilha (){ if(topo!= 0) { /* Possui elemento na pilha */ Topo --; } return(pilha[topo]); } else return(vazia); /* pilha vazia */ elemento elemento 3 elemento elemento

16 Remoção na pilha #define VAZIA desempilha (){ if(topo!= 0) { /* Possui elemento na pilha */ Topo --; } return(pilha[topo]); } else return(vazia); /* pilha vazia */ 3 elemento elemento 3 elemento elemento

17 Pilhas - Lista Sequenciais! consultar o tamanho atual da pilha altura (PILHA) { return (Topo-1); }! consultar o topo da pilha topo (PILHA[ ]) { return(pilha[topo-1]); } 17

18 Complexidade das Operações em Pilha em Lista Sequenciais! Todas as operações são O(1)! qualquer que seja o número de elementos em PILHA[ ], somente um número constante de! Se for necessário tratar overflow com realocação, inserção pode ter complexidade de pior caso O(n)! Uma nova lista de comprimento maior seria alocada! Todos os elementos são copiados para a nova lista 18

19 ! Seja F uma fila, e v um valor:! enfila (v): v é inserido no final da fila F! desenfila(): descarta o elemento mais antigo da fila F, ou seja, o elemento que está no início de F! comprimento(f): retorna o número de elementos na fila F! A política de inserção e remoção de dados à maneira de uma fila é conhecida como FIFO First In First Out 19

20 " enfila() e desenfila() " como as inserções são realizadas em uma extremidade, é necessárui 20

21 ! Seja F uma fila, e v um valor:! enfila (v): v é inserido no final da fila F! desenfila(): descarta o elemento mais antigo da fila F, ou seja, o elemento que está no início de F! comprimento(f): retorna o número de elementos na fila F! A política de inserção e remoção de dados à maneira de uma fila é conhecida como FIFO First In First Out 21

22 ! enfila()! inserções realizadas em uma extremidade: no final da fila! índice auxiliar: Fim! desenfila()! remoções realizadas no início da fila! índice auxiliar: Inicio 22

23 " enfila(): respeitar o tamanho máximo da lista " desenfila(): pode esvaziar a fila " inicialmente fila vazia: Inicio = 0 e Fim =

24 " enfila( elemento 1, FILA)

25 " enfila( elemento 1, FILA) elemento

26 " enfila( elemento 2, FILA) elemento 1 elemento

27 " enfila( elemento 3, FILA); " enfila ( elemento, FILA); elemento 1 elemento 2 elemento

28 " desenfila(fila); elemento 1 elemento 2 elemento

29 " desenfila(fila); 0 elemento 2 elemento

30 " enfila( elemento, FILA); 0 elemento 2 elemento 3 elemento

31 " desenfila (FILA); 0 1 elemento 3 elemento

32 " enfila ( elemento 5, FILA); " enfila ( elemento 6, FILA); 0 1 elemento 3 elemento elemento 5 elemento

33 ! para aproveitar o espaço no caso de lista sequencial " incrementamos as posições de forma circular 0 1 elemento 3 elemento elemento 5 elemento

34 ! podemos definir uma função auxiliar responsável por incrementar o valor de um índice de forma circular: int incr (int i) { if (i == N -1) return (0); else return (i + 1); } 3

35 ! de forma mais compacta, podemos utilizar a operação módulo (% em C)! x%y # resto da divisão de x por y int incr (int i) { if (i == N -1) return (0); else return (i + 1); } 35

36 ! então, definindo um tipo fila: int Inicio; int Fim; int FILA [TMAX]; 36

37 ! inicializando a fila - está vazia Inicio = Fim = 0; 37

38 ! enfilando elementos:! inserir somente se houver espaço disponível enfila(valor, FILA) { if ((Fim+1)% TMAX)!= Inicio ){ FILA[Fim] = v; Fim = (Fim+1) % TMAX; }else printf ( overflow \n ); } 38

39 ! desenfilando elementos:! somente se existir elementos na fila desenfila(fila){ if( Início!= Fim){ valor = FILA[Início]; Início= (Início +1)%TMAX; if ( Inicio == ( Fim /* último elemento foi retirado da fila */ Inicio = Fim = 0; /* FILA se tornou vazia */ } else printf ( underflow\n ; } 39

40 Exercício Considere a existência de uma PILHA de números inteiros, cuja interface da seguinte forma: int PILHA[TMAX]; int Topo = 0; void empilha (int v, int PILHA[]); int desempilha (int PILHA[]); Usando apenas as funções declaradas, implemente uma função que receba duas pilhas, p1 e p2, e passe todos os elementos da pilha p2 para o topo da pilha p1. 0