Pilhas e Filas Acesso

Transcrição

1 Listas lineares especiais Pilhas e Filas Acesso consulta inserção remoção Disciplina restrita de acesso Disciplina restrita acesso permitido somente em alguns nós Listas lineares especiais mais usuais LO Last In First Out o último componente inserido é o primeiro a ser retirado Pilha Pilhas e Filas Pilhas: FO First In First Out o primeiro componente inserido é também o primeiro a ser retirado Fila Filas:

2 Fila implementada sobre arranjo Filas Contigüidade física : limite inferior da área : da fila : final da fila : limite superior da área Fila vazia = 0 Evolução da Fila Operações sobre Filas Operações válidas: criar uma fila vazia inserir um nó no final da fila excluir o nó do da fila consultar modificar nó do da fila destruir a fila

3 Criação de fila - contigüidade física Função CriarFila (var,,, :inteiro;n:inteiro; : TipoFila): lógico; { Cria uma fila, inicialmente vazia, com número máximo de N nós } { Devolve os indicadores de e final da área disponível, e de e de final da fila } Função AlocarArea (N: inteiro; ARR: TipoFila; var INI: inteiro): lógico; { Aloca espaço de N nós sobre o arranjo ARR para a fila } { Devolve o índice inicial deste espaço } { Retorna falsa se não encontrar o espaço solicitado em ARR } Espaço disponível para a fila Criação de fila - contigüidade física Função CriarFila (var,,, :inteiro;n:inteiro; : TipoFila): lógico; { Cria uma fila, inicialmente vazia, com número máximo de nós N } { Devolve os indicadores de e final da área disponível, e de e de final da fila } var INI : inteiro; CriarFila := falso; se AlocarArea (N, ARR, INI) { função lógica - retorna verdadeira caso consiga alocar N posições sobre o arranjo ARR, iniciando em INI } então := INI; := INI N; := := - 1; CriarFila := verdadeiro CriarFila ; Inserção em fila - contigüidade física Testar se tem espaço livre para inserir: atrás na frente no meio Inserção em fila - contigüidade física Função InserirFila (,, : inteiro; var : inteiro; : TipoFila; INF: TipoNó): lógico; { Insere Função um InserirFila novo nó no final (, da, fila } : inteiro; var : inteiro; : TipoFila; INF: TipoNó): lógico; InserirFila { Insere um := novo falso; nó no final da fila } se (( - 1) e ( ou )) { testes de espaço livre } então { tem espaço } se = - 1 { fila está vazia } então := := ; { insere 1 o nó } senão se = então := { insere no }... senão := + 1; {insere atrás ou no... meio} [ ] := INF; InserirFila:= verdadeiro InserirFila ;

4 Remoção de fila - contigüidade física Função ExcluirFila (,, : inteiro; var : inteiro) :lógico; { Exclui o nó que está no da fila } Remoção de fila - contigüidade física Função ExcluirFila (,, : inteiro; var : inteiro) :lógico; { Exclui o nó que está no da fila } ExcluirFila := falso; se - 1 então { fila não está vazia } se = { tem 1 só nó na fila } então := := - 1 { a fila fica vazia } senão se = { nó está na última posição } então := { para } senão := + 1; { avança} ExcluirFila:=verdadeiro ExcluirFila ; Consulta à fila - contigüidade física Função ConsultarFila (: TipoFila;, : inteiro; var INF: TipoNó): lógico; { Devolve o valor contido no nó que está no da fila } Função ConsultarFila (: TipoFila;, : inteiro; ConsultarFila := falso; var INF: TipoNó): lógico; se { Devolve o - 1 valor { fila contido não está no nó vazia que } está no da fila } então INF := [ ]; ConsultarFila := verdadeiro ConsultarFila ;......? Destruição de fila - contigüidade física Função DestruirFila (: TipoFila;, : inteiro); { Libera a área ocupada pela fila } LiberarArea (,, ); DestruirFila ;

5 Filas encadeadas Filas Encadeamento PtFila Endereço do primeiro da fila, para remoção Frente Endereço do final da fila, para inserção Final F1 F2 F3 Fn Filas encadeadas - com descritor Criação de fila encadeada com descritor Prim Ult F Descritor tipo DescrFila Prim: primeiro da fila Ult : último da fila PtDF Prim Ult Função CriarFila ( var PtDFila: TipoDFila) : lógico; { Aloca descritor e inicializa em fila vazia } Função CriaFila ( var F: Fila) : lógico; { se Aloca alocar descritor (PtDFila) e inicializa em fila vazia } então PtDFila. Prim := PtDFila. Ult := nil; { fila vazia } CriarFila := verdadeiro senão CriarFila := falso CriarFila ;

6 Inserção em fila encadeada sem descritor Proc InserirFila (var PtFila : TipoPtNó; Inf: TipoInfo ); { Insere um novo nó com Inf no final da fila } var PtAux, PtNovo : TipoPtNó; alocar (PtNovo); PtNovo Proc InserirFila. Info := Inf; (var { coloca PtFila a informação : TipoPtNó; no Inf: novo TipoInfo nó } ); PtNovo { Insere. um Prox novo := nó nil; com { indica Inf no que final será da fila o último } da fila } se PtFila = nil então PtFila := PtNovo { lista estava vazia - inserir o primeiro nó } senão PtAux := PtFila; { coloca PtAux no da lista } enquanto PtAux. Prox nil faça PtAux := PtAux. Prox; { PtAux pára no último nó } PtAux. Prox := PtNovo { encadeia o novo nó com o último } InserirFila ; Inserção em fila encadeada com descritor PtFila Inf Inserção em fila encadeada com descritor Remoção de fila encadeada com descritor Função InserirFila (var PtDFila:TipoDFila; Inf:TipoInfo):lógico { Insere nó com Inf no final da fila } var Pt:TipoPtNó; InserirFila := falso; se PtDFila nil { existe a fila } então alocar (Pt) Pt. Info := Inf; Pt. Prox := nil; se PtDFila. Prim = nil então PtDFila. Prim := Pt senão (PtDFila. Ult). Prox := Pt; PtDFila. Ult := Pt; InserirFila := verdadeiro InserirFila ;

7 Remoção de fila encadeada com descritor Função RemoverFila (var PtDFila: TipoDFila) : lógico; { remove o nodo que está no da fila } var PtAux: TipoPtNó; RemoverFila := falso; se PtDFila nil { a fila existe } então se PtDFila. Prim nil { tem pelo menos 1 nó na fila } então PtAux := PtDFila. Prim; PtDFila. Prim := PtAux. Prox; liberar (PtAux); se PtDFila. Prim = nil { a fila ficou vazia } então PtDFila. Ult := nil; RemoverFila := verdadeiro RemoverFila ; Consulta à fila encadeada com descritor Função ConsultarFila (PtDFila: TipoDFila; var Inf: TipoInfo) : lógico; { devolve o valor contido no primeiro nó da fila } ConsultarFila := falso; se PtDFila nil { a fila existe } então se PtDFila. Prim nil { a fila não está vazia } então Inf := (PtDFila. Prim). Info; ConsultarFila := verdadeiro ConsultarFila ;? Destruição de fila encadeada com descritor PtDFila Prim Ult Função DestruirFila (var PtDFila: TipoDFila) : lógico; { Libera posições ocupadas pela fila } DestruirFila := verdadeiro; se PtDFila = nil { a fila não existe } então DestruirFila := falso senão LiberarLista (PtDFila) DestruirFila ; F Liberação de lista encadeada com descritor Proc LiberarLista (var PtDFila : TipoDFila); { Libera lista com descritor Prim + Ult e devolve F = nil } var P1, P2: TipoPtNó; { Nó: Info + Prox } se PtDFila. Prim nil { lista não está vazia } então { libera posições ocupadas pela lista } P1 := PtDFila. Prim; repita P2 := P1. Prox; liberar (P1); P1 := P2 até que P1 = nil; liberar (PtDFila ); { libera o descritor } PtDFila := nil { retorna PtDFila = nil } LiberarLista ;

8 Exercícios sugeridos - filas Considere 3 filas (F1, F2 e F3), sendo a cada uma associado um código (valores dos códigos A, B e C). Construa os seguintes programas: - programa que insere um novo nodo em uma das filas - fornecido código relativo à fila, e o valor a ser inserido no nodo; - programa que remove um nodo de uma fila, sendo primeiro removidos todos os nodos da fila F1, depois da F2 e por último da F3. Resolva este problema considerando: alocação seqüecial alocação encadeada Exercícios sugeridos - pilha e fila Considere a existência de uma pilha e de uma fila. Escreva um procedimento que, através do menu abaixo, identifique qual a tarefa a ser executada: 1. Ler um valor. Se for positivo, inserir na pilha, caso contrário, inserir na fila 2. Remover um elemento da pilha e colocar na fila 3. Remover um elemento da fila e colocar na pilha Resolva o problema utilizando: pilha e fila por contigüidade pilha e fila encadeada pilha encadeada e fila por contigüidade pilha por contigüidade e fila encadeada