Estruturas de Dados aula 4 Estruturas de Dados – aula 2 – Complexidade e Listas Ligadas Estruturas de Dados aula 4 Sistemas de Informação EaD

Listas Duplamente Ligadas Na célula, além de um ponteiro para o próximo elemento, há um ponteiro para o elemento anterior Vantagens Percurso nos dois sentidos Exclusão facilitada O(1) Desvantagens Mais memória Um pouco mais complexo para manipular As listas duplamente ligadas tem um ponteiro a mais em cada célula, para o elemento anterior. Dessa forma, é possível fazer o percurso nos dois sentidos e a exclusão é facilitada. As desvantagens são o uso maior de memória e a complexidade um pouco maior

Célula struct Celula { char dado[80]; struct Celula * ant; * prox; } Aqui mostramos a declaração da célula e a representação gráfica de uma célula. Note o ponteiro a mais ant.

Exemplo de Lista Note os ponteiros para os dois lados nas células Aqui exibimos um exemplo de lista já pronta. Note os ponteiros para os dois lados nas células Note os ponteiros para os dois lados nas células

Operações São as mesmas que nas listas ligadas Cuidados com os dois ponteiros Facilidade: podemos acessar o elemento anterior, o que não era possível As operações são as mesmas que nas listas ligadas, com o cuidado de atualizar e verificar o ponteiro para o elemento anterior. Temos agora uma facilidade que é possível voltar ao elemento anterior, o que não podia ser feito nas listas ligadas.

Pilhas Estrutura linear Somente o topo é visível Primeiro a entrar, último a sair. Operações: Empilhar Desempilhar Pilha Vazia Iniciar Consultar topo A pilha é uma estrutura linear, onde somente o elemento no topo da pilha é visível, como uma pilha de pratos, de livros, etc. A regra fundamental da pilha é “primeiro a entrar, último a sair”. As operações da pilha são as listadas: empilhar, desempilhar, verificação de pilha vazia, iniciar pilha e verificação do topo da pilha

Operações topo 3 10 5 7 9 8 aqui exibimos uma figura representando uma pilha de números inteiros. O elemento indicado é o topo da pilha 7 9 8

Operações topo 3 10 5 Não se enxerga o resto da pilha, somente o topo 7 9 8

Operações 3 topo 10 5 Desempilhar 7 9 8 a ação de desempilhar retira o elemento, e o elemento seguinte passa para o topo 7 9 8

Operações 20 topo 10 5 Empilhar 7 9 8 A ação de empilhar coloca elemento no topo. 7 9 8

Operações topo 20 10 5 Empilhar O novo elemento foi para o topo 7 9 8

Operações topo 20 10 5 Empilhar o topo antigo passa a ser oculto 7 9 8

Aplicação – verificação de parênteses Aplicação de pilha – verificação de seqüência de parênteses correta Ex: Correta: ((()))()(()) Incorreta: (())) ou (() Idéia: ao abrir parênteses empilha o símbolo. Quando fechar, desempilha No final, pilha deve estar vazia Aplicação de pilha – verificação de seqüência de parênteses correta Ex: Correta: ((()))()(()) Incorreta: (())) ou (() Idéia: ao abrir parênteses empilha o símbolo. Quando fechar, desempilha No final, pilha deve estar vazia

Exemplo (()) no início, lemos o primeiro parênteses. como é um abertura, ele vai para o topo da pilha topo (

Exemplo (()) outro abre parênteses, vai novamente para a pilha ( topo (

Exemplo (()) ( quando vem um fecha parênteses, desempilha um elemento topo (

Final de seqüência, pilha vazia, ok Exemplo (()) ( ( veio outro fecha, desempilha. Como a seqüência acabou e a pilha está vazia, a seqüência é válida topo nil Final de seqüência, pilha vazia, ok

Exemplo com erro (() vamos agora mostrar uma seqüência com erro. Note que falta um parênteses a fechar

Exemplo (() Colocamos o parênteses na pilha topo (

Exemplo (() Mais um elemento na pilha ( topo (

Final da seqüência, pilha não vazia, ERRO ! Exemplo (() ( chegamos no final da seqüência, como a pilha não está vazia, há erro topo ( Final da seqüência, pilha não vazia, ERRO !

Exemplo ()) Outro exemplo com erro. Colocamos o elemento na pilha topo (

Exemplo ()) ( Desempilha o elemento topo nil

Precisaria desempilhar com pilha vazia, ERRO Exemplo ()) ( Precisaríamos desempilhar, mas a pilha está vazia, portanto há erro topo nil Precisaria desempilhar com pilha vazia, ERRO

Filas Estrutura linear simulando filas da vida real (sem furo de fila). FIFO – First In, First Out – primeiro que entra, primeiro que sai Aplicações: Filas de impressão Filas de sistemas (bancos, consultórios) Filas de processos do sistema operacional Estrutura linear simulando filas da vida real (sem furo de fila). FIFO – First In, First Out – primeiro que entra, primeiro que sai Aplicações: Filas de impressão Filas de sistemas (bancos, consultórios) Filas de processos do sistema operacional

Note que temos início e fim da fila Filas Note que temos início e fim da fila aqui temos uma representação gráfica de fila de números inteiros Note que temos apontadores para o início e final da fila.

Operações Inserir – coloca elemento no final da fila Remover – retira elemento do início da fila Iniciar – inicia uma fila vazia Fila Vazia – verifica se uma fila está vazia Possíveis implementações: Usando listas Usando vetores as operações na fila são a de iniciar, remover, inserir e verificação de fila vazia. Há diversas formas de se implementar as filas, podemos usar vetores ou listas ligadas.

Implementação com vetores Podemos implementar as listas com vetores. Nesse caso, após algumas operações de remoção pode ser necessária uma “limpeza” Inserção – no final da fila Remoção – no início da fila exibiremos a implementação de filas com vetores. Como as posições dos vetores são fixas, pode ser necessária limpeza periódica A inserção se dá no final da fila, e a remoção no início da fila. Como nas pilhas, apenas o início da fila é visível

Inicialização de fila com vetor 1 2 3 4 5 6 7 8 9 inicio final a fila está vazia se o final é menor que o início.

Inserindo na fila 1 2 3 4 5 6 7 8 9 final inicio ABC Quando inserimos, avançamos o final e colocamos o dado na fila ABC 1 2 3 4 5 6 7 8 9 final inicio

Após algumas inserções após 5 inserções: ABC DEF GHI XYZ MKW 1 2 3 4 5 6 7 8 9 inicio final nesta figura, mostramos somente 9 posições da lista, mas ela pode ser maior.

Remoção 1 2 3 4 5 6 7 8 9 inicio final DEF GHI XYZ MKW note que após a remoção sobra espaço no início antigo da fila DEF GHI XYZ MKW 1 2 3 4 5 6 7 8 9 inicio final

após mais duas remoções Após mais remoções, mais espaço sobrará no início do vetor XYZ MKW 1 2 3 4 5 6 7 8 9 inicio final Após mais remoções, mais espaço sobrará no início do vetor

Limpeza da fila 1 2 3 4 5 6 7 8 9 i inicio Os elementos são copiados para o início da fila XYZ XYZ MKW 1 2 3 4 5 6 7 8 9 inicio final Os elementos são copiados para o início da fila i

Limpeza da fila 1 2 3 4 5 6 7 8 9 Outra cópia inicio final i XYZ MKW 1 2 3 4 5 6 7 8 9 Outra cópia inicio final i

o valor do final é ajustado Limpeza da fila o valor do final é ajustado XYZ MKW XYZ MKW 1 2 3 4 5 6 7 8 9 inicio o valor do final é ajustado final i

finalmente, o valor do início os valores anteriores são Limpeza da fila finalmente, o valor do início os valores anteriores são desconsiderados. XYZ MKW XYZ MKW 1 2 3 4 5 6 7 8 9 finalmente, o valor do início os valores anteriores são desconsiderados. inicio final i

Fila com prioridade Fila em que alguns elementos podem ser atendidos fora da ordem FIFO Vida real: idosos, grávidas, etc. Pode ser implementado com um heap Heap: estrutura linear em forma de árvore, implementada em um vetor. No heap, os filhos são menores que os pais. a fila com prioridade simula filas na vida real onde algumas pessoas podem “furar” a fila, como idosos, grávidas, etc. Podemos usar o heap para implementar a fila com prioridade Um heap é uma estrutura com forma de árvore em que o valor dos filhos é menor que a dos pais

Exemplo Mostramos aqui um exemplo de heap. Note que o valor dos pais é sempre maior ou igual a dos filhos

Implementação Usando apenas um vetor. Pai – índice do filho / 2 (desprezando a parte fracionária) filho da direita – (índice do pai * 2) mais 1 filho da esquerda (índice do pai * 2) 30 20 10 14 3 5 8 5 11 1 2 3 1 2 3 4 5 6 7 8 9 10 11 12 Podemos implementar o heap apenas com um vetor. Para cada elemento, o índice do seu pai se obtém dividindo-se o índice por 2. Para obter os filhos esquerdo e direito, multiplica-se o índice e soma-se um para o direito. Mostramos o exemplo anterior no vetor

Inserindo Para inserir, colocaremos o elemento no final do heap, e faremos o mesmo “subir” na árvore até que a propriedade do heap esteja satisfeita Para inserir, colocaremos o elemento no final do heap, e faremos o mesmo “subir” na árvore até que a propriedade do heap esteja satisfeita

Inserção Nestre exemplo, o número 15 é inserido

Inserção Como o pai dele era menor, ele troca de posição

Inserção Está ok Faz outra troca. Note que agora o pai dele é maior, então devemos parar Faz outra troca. Note que agora o pai dele é maior, então devemos parar

Exclusão A Exclusão se faz no pai de todos os elementos. Trocamos o elemento pelo último da fila, e consertamos o heap. A Exclusão se faz no pai de todos os elementos. Trocamos o elemento pelo último da fila, e consertamos o heap.

Como o “5” era menor que o filho, ele desce Exclusão Como o “5” era menor que o filho, ele desce Como o “5” era menor que o filho, ele desce

Novamente tem um filho maior, desce de novo Exclusão Novamente tem um filho maior, desce de novo Novamente tem um filho maior, desce de novo

O filho ainda é maior,então desce de novo. Agora já está Exclusão O filho ainda é maior,então desce de novo. Agora já está no nível mais baixo. Mas ele pararia se fosse maior que os filhos O filho ainda é maior,então desce de novo. Agora já está no nível mais baixo. Mas ele pararia se fosse maior que os filhos

Eficiência Exclusão e inclusão – altura da árvore – O(log n) – bom ! Sem heap – ordenação – O(n log n) e O(n) - piores Analisando a eficiência do heap, a exclusão e inclusão são executadas em tempo O(log n), considerado bom Se não for usado o heap. será necessário ordenar o vetor, que custa O(n log n) que é pior. Ou senão fazer uma busca a cada elemento. Portanto, o heap é eficiente para filas com prioridade

Fila circular Fila em que não há fim Usada em rotinas com rodízio Sistemas Operacionais. Mostraremos uma implementação com uma variação de lista duplamente ligada. A fila circular não tem início e fim. Ela é útil em sistemas em que há “rodízio”, como em sistemas operacionais. Mostraremos uma forma de implementar a fila circular com lista duplamente ligada.

nas pontas são ligados entre si, formando um ciclo. Exemplo Nesta figura, exibimos um exemplo de fila circular. note que os elementos nas pontas são ligados entre si, formando um ciclo. Nesta figura, exibimos um exemplo de fila circular. note que os elementos nas pontas são ligados entre si, formando um ciclo.