Estruturas de Dados aula 4

Apresentação em tema: "Estruturas de Dados aula 4"— Transcrição da apresentação:

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

2 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

3 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.

4 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

5 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.

6 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

7 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

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

9 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

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

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

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

13 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

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

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

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

17 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

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

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

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

21 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 !

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

23 Exemplo ()) ( Desempilha o elemento topo nil

24 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

25 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

26 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.

27 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.

28 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

29 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.

30 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

31 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.

32 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

33 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

34 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

35 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

36 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

37 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

38 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

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

40 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

41 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

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

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

44 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

45 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.

46 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

47 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

48 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

49 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

50 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.

51 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.