1 / 30

Algoritmos e Estruturas de Dados

Prof. Me. Claudio Benossi claudio@beno.com.br. Algoritmos e Estruturas de Dados. Pilhas e Filas. Pilhas e Filas. Pilhas e filas são casos especiais das listas encadeadas. Ambas possuem regras rigorosas para acessar os dados armazenados nelas.

Download Presentation

Algoritmos e Estruturas de Dados

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Prof. Me. Claudio Benossi claudio@beno.com.br Algoritmos e Estruturas de Dados Pilhas e Filas

  2. Pilhas e Filas • Pilhas e filas são casos especiais das listas encadeadas. • Ambas possuem regras rigorosas para acessar os dados armazenados nelas. • As operações de recuperação de dados são destrutivas, ou seja, para se alcançar dados intermediários a tais estruturas, é necessário destruir sequencialmente os dados anteriores.

  3. Pilhas • É uma das estruturas de dados mais simples • É a estrutura de dados mais utilizada em programação, sendo inclusive implementada diretamente pelo hardware da maioria das máquinas modernas. • A idéia fundamental da pilha é que todo o acesso a seus elementos é feito através do seu topo. • Assim, quando um elemento novo é introduzido na pilha, passa a ser o elemento do topo, e o único elemento que pode ser removido da pilha é o do topo.

  4. Pilhas:: Aplicações • Verificação de parênteses. • Retirada de vagões de um trem. • Retirada de mercadorias em um caminhão de entregas. • Conversão de um número na base 10 para outra base numérica.

  5. Pilhas • Os elementos da pilha são retirados na ordem inversa à ordem em que foram introduzidos: o primeiro que sai é o último que entrou (LIFO – last in, first out). • Existem duas operações básicas que devem ser implementadas numa estrutura de pilha: • operação para empilhar (push) um novo elemento, inserindo-o no topo, • operação para desempilhar (pop) um elemento, removendo-o do topo

  6. Pilhas:: Push topo push(a) push(b) b a x m k

  7. Pilhas:: Push b topo a a topo x x m m k k x topo m k push(a) push(b)

  8. Pilhas:: Pop topo pop(b) pop(a) b a x m k

  9. Pilhas:: Pop a topo x x topo m m k k b topo a x m k pop(b) pop(a)

  10. Pilhas:: Implementação de pilha usando vetor 0 t n-1 pilha[0..n-1] • Supondo a pilha está armazenada em um vetor pilha[0..n-1]. • Considerando que os elementos são inteiros (isso é só um exemplo, os elementos de pilha poderiam ser quaisquer outros objetos). • A parte do vetor ocupada pela pilha será:

  11. Pilhas:: Implementação de pilha usando vetor #define MAX 50 struct pilha { int n; int vet[MAX]; } tipoPilha; 172 173

  12. Pilhas:: Implementação de pilha usando estruturas typedef struct noh { float info; struct no *prox; } tipoNo; struct pilha { tipoNo* topo; } tipoPilha;

  13. Pilhas:: Operações básicas • Criar uma estrutura de pilha; • Inserir um elemento no topo (push); • Remover o elemento do topo (pop); • Verificar se a pilha está vazia; • Liberar a estrutura de pilha

  14. Pilhas:: Criar uma estrutura de pilha tipoPilha* criar(void) { tipoPilha *p; p = (tipoPilha*) malloc(sizeof(tipoPilha)); p->topo = NULL; return p; }

  15. Pilhas:: Inserir o elemento do topo - push() tipoPilha push(tipoPilha *p, float v) { tipoNo* aux; aux = (tipoNo) malloc(sizeof(tipoNo)); aux -> info = v; aux -> prox = p->topo; return aux; }

  16. Pilhas:: Remover o elemento do topo - pop() void pop(tipoPilha *p) { float v; tipoNo* aux; if (vazia(p)) { printf(“Pilha vazia.”); exit(1); /*aborta o programa*/ } v = p->topo->info; aux = p->prox; free(p); printf(“Retirou o elemento %d”, v); }

  17. Pilhas:: Verificar se a pilha está vazia int vazia(tipoPilha *p) { return (p->topo == NULL); }

  18. Pilhas:: Liberar a estrutura de pilha void libera(tipoPilha *p) { tipoNo* q = p->topo; while (q != NULL) { tipoNo *t = q->prox; free(q); q = t; } free(p); } 174

  19. Filas • São listas lineares que adotam a política FIFO (First In First Out – o primeiro que entra é o primeiro que sai) para a manipulação de elementos. • As inserções são feitas no final da fila. • As remoções são feitas no início da fila. • A consulta na fila é feita desenfileirando elemento a elemento até encontrar o elemento desejado ou chegar ao final da fila.

  20. Filas:: Aplicações • Alocação de recursos para impressão de documentos em uma impressora (spooler de impressão). • Atendimento de processos requisitados ao um sistema operacional. • Ordenação do encaminhamento dos pacotes em um roteador. • Buffer para gravação de dados em mídia.

  21. Filas:: Aplicações fila para pouso fila para decolagem

  22. Filas de tamanho variável:: Inserção x m k a x m k b a x m k a b

  23. Filas de tamanho variável:: Remoção x m k a x m k b a x m k k m

  24. Filas de tamanho fixo x a b m x a k m x a k b m

  25. Filas:: Estrutura de uma fila

  26. Filas:: Operações básicas • Criação • Destruição • Inserção de um elemento • Remoção de um elemento • Localização de um elemento para consulta ou alteração • Ordenação de uma lista • Intercalação de duas listas • Concatenação de duas listas • Divisão de uma lista em duas

  27. Filas:: Criação de uma fila typedef struct { int info; /* outros componentes*/ } tipoItem; typedefstruct no { tipoItem item; struct no *prox; } tipoNo; typedefstruct { tipoNoh frente; tipoNoh tras; } tipoFila;

  28. Filas:: Inserção de um elemento void ffvazia(tipoFila *fila) { fila->frente = (tipoNo) malloc(sizeof(tipoNo)); fila->tras = fila->frente; fila->frente->prox = NULL; } int vazia(tipoFila fila) { return (fila.frente == fila.tras); } void enfileira(tipoItem x, tipoFila *fila) { fila->tras->prox = (tipoNo) malloc(sizeof(tipoNo)); fila->tras = fila->tras->prox; fila->tras->item = x; fila->tras->prox = NULL; }

  29. Filas:: Remoção de um elemento void desenfileira(tipoFila *fila) { ptr p; if (vazia(*fila)) { printf("Erro: Fila vazia.\n"); return; } p = fila->frente; fila->frente = fila->frente->prox; free(p); printf("Item da fila excluido com sucesso."); getch(); } 175

  30. Questões

More Related