Análise de Algoritmos

(1)

Análise de Algoritmos

(2)

• Conjuntos manipulados por algoritmos podem crescer, encolher ou sofrer mudanças

• Dicionários

▫ Inserção de elementos

▫ Remoção de elementos

▫ Testar pertinência de elementos

• Melhor forma de implementar um conjunto dinâmico

▫ Operações que devem ser admitidas

▫ Forma de acesso ou manipulação dos elementos

• Elementos

▫ Chave + ponteiro(s)

www.nakamura.eti.br/eduardo Análise de Algoritmos 2

(3)

• SEARCH (S,k)

▫ Existe o elemento k no conjunto S?

▫ Retorna o elemento (ponteiro)

• INSERT (S,x)

▫ Insere o elemento x no conjunto S

• DELETE (S,x)

▫ Remove o elemento x no conjunto S

(4)

• MINIMUM (S)

▫ Retorna o elemento (ponteiro) de menor valor (chave) do conjunto S

• MAXIMUM (S)

▫ Retorna o elemento (ponteiro) de maior valor (chave) do conjunto S

(5)

• SUCCESSOR (S,x)

▫ Retorna o elemento que seguinte ao elemento de valor x no conjunto S, se houver

• PREDECESSOR (S,x)

▫ Retorna o elemento que antecede o elemento de valor x no conjunto S, se houver

(6)

• Funcionamento

▫ Last-in, first-out (LIFO)

• Operações

▫ PUSH (inserção ou INSERT)

▫ POP (remoção ou DELETE)

• Implementação com arranjo

▫ Arranjo S[1..n]

▫ topo

(7)

• Funcionamento

▫ Last-in, first-out (LIFO)

• Operações

▫ PUSH (inserção ou INSERT)

▫ POP (remoção ou DELETE)

• Implementação com arranjo

1 2 3 4 5 6

S

topo=0

1 2 3 4 5 6

S 1 7 4 3 2

topo=5

(8)

STACK-EMPTY(S)

1: if topo = 0 then 2: return TRUE;

3: else

4: return FALSE;

5: end if PUSH(S,x)

1: topo  topo + 1;

2: S[topo]  x;

POP(S)

1: if STACK-EMPTY(S) then 2: error UNDERFLOW

3: else

4: topo  topo - 1;

5: return S[topo+1];

6: end if

(9)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

STACK-EMPTY(S) = TRUE

1 2 3 4 5 6

S

topo

(10)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

3: else

6: end if

POP(S) = UNDERFLOW

1 2 3 4 5 6

S

topo

(11)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

1 2 3 4 5 6

S 10

topo

PUSH(S,10)

(12)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

3: else

6: end if

1 2 3 4 5 6

S 10 5

topo

PUSH(S,5)

(13)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

1 2 3 4 5 6

S 10 5 4

topo

PUSH(S,4)

(14)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

3: else

6: end if

1 2 3 4 5 6

S 10 5 4

topo

POP(S)=4

(15)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

1 2 3 4 5 6

S 10 5 13

topo

PUSH(S,13)

(16)

STACK-EMPTY(S)

3: else

4: return FALSE;

5: end if PUSH(S,x)

2: S[topo]  x;

POP(S)

3: else

6: end if

Qual é o custo destas

operações?

(17)

• Funcionamento

▫ First-in, first-out (FIFO)

• Operações

▫ ENQUEUE (inserção ou INSERT)

▫ DEQUEUE (remoção ou DELETE)

•

(18)

1. Escreva o ENQUEUE e o DEQUEUE para detectar o estouro negativo e o estouro positivo de uma fila

2. Descreva como implementar duas pilhas em um único arranjo (escreva os algoritmos)

▫

Nenhuma das pilhas sofre um estouro positivo a menos que o total de elementos nas duas pilhas juntas seja n

▫

Operações PUSH e POP com custo O(1)

3. Escreva o algoritmo de remoção para árvore de pesquisa binária e mostre qual é a sua complexidade de tempo no pior caso

4. Escreva um procedimento não recursivo de tempo O(n)

que, dada uma árvore binária de n nós, imprima a chave de cada nó

(19)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

1 2 3 4 5 6

Q

inicio, fim

(20)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

2: if inicio = n then 3: inicio  1;

4: else

5: inicio  inicio + 1;

6: end if 7: return x;

1 2 3 4 5 6

Q 8

fim

ENQUEUE(Q,8)

inicio

(21)

1 2 3 4 5 6

Q 8 4

ENQUEUE(Q,4)

fim

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if DEQUEUE(Q)

1: x  Q[inicio]; _inicio

(22)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

4: else

1 2 3 4 5 6

Q 8 4 1

ENQUEUE(Q,1)

fim inicio

(23)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

1 2 3 4 5 6

Q 8 4 1 5

ENQUEUE(Q,5)

fim inicio

(24)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

4: else

1 2 3 4 5 6

Q 8 4 1 5 2

ENQUEUE(Q,2)

fim inicio

(25)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

1 2 3 4 5 6

Q 8 4 1 5 2

DEQUEUE(Q) = 8

inicio fim

(26)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

4: else

1 2 3 4 5 6

Q 8 4 1 5 2

DEQUEUE(Q) = 4

fim inicio

(27)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

1 2 3 4 5 6

Q 8 4 1 5 2 9

ENQUEUE(Q,9)

inicio fim

(28)

ENQUEUE(Q,x)

1: Q[fim]  x;

2: if fim = n then 3: fim  1;

4: else

5: fim  fim + 1;

6: end if

DEQUEUE(Q)

1: x  Q[inicio];

4: else

1 2 3 4 5 6

Q 3 4 1 5 2 9

ENQUEUE(Q,3)

fim inicio

(29)

• Utilizam ponteiros para ligar os elementos

• Lista ligada simples

▫ Um ponteiro para o próximo elemento

• Lista duplamente ligada

▫ Um ponteiro para o próximo elemento

▫

(30)

LIST-SEARCH(L,k) 1: x  L.inicio;

2: while x  NIL and x.chave  k do 3: x  x.proximo;

4: end while 5: return x;

/

inicio

9 2 6 4 /

LIST-SEARCH(L,9) ? L

LIST-SEARCH(L,4) ? LIST-SEARCH(L,5) ?

(31)

LIST-SEARCH(L,k) 1: x  L.inicio;

2: while x  NIL and x.chave  k do 3: x  x.proximo;

(32)

LIST-INSERT(L,x)

1: x.proximo  NIL;

2: primeiro  (L.inicio).proximo;

3: if primeiro  NIL then 4: x.proximo  primeiro;

5: primeiro.anterior  x;

6: end if

7: (L.inicio).proximo  x;

8: x.anterior  L.inicio;

/

inicio

9 2 6 4 /

x

7

L

(33)

LIST-INSERT(L,x)

6: end if

(34)

LIST-INSERT(L,x)

6: end if

/

inicio

9 2 6 4 /

7

primeiro

x

/

L

(35)

LIST-INSERT(L,x)

6: end if

(36)

LIST-INSERT(L,x)

6: end if

/

inicio

9 2 6 4 /

7

primeiro

x

L

(37)

LIST-INSERT(L,x)

6: end if

(38)

LIST-INSERT(L,x)

6: end if

/

inicio

9 2 6 4 /

7

primeiro

x

L

(39)

LIST-INSERT(L,x)

6: end if

(40)

LIST-INSERT(L,x)

6: end if

/

inicio

9 2 6 4 /

x

7

L

(41)

LIST-INSERT(L,x)

6: end if

Qual é o custo desta

operação?

(42)

LIST-INSERT(L,x)

6: end if

/

inicio

9 2 6 4 /

x

7

Por que não inserir no fim da lista?

L

(43)

LIST-DELETE(L,x)

1: a  x.anterior;

2: p  x.proximo;

3: FREE(x);

4: a.proximo  p;

5: if p  NIL then 6: p.anterior  a;

7: end if

x

inicio

(44)

LIST-DELETE(L,x)

2: p  x.proximo;

3: FREE(x);

4: a.proximo  p;

7: end if

x

a p

/

inicio

9 2 6 4 /

L

(45)

LIST-DELETE(L,x)

2: p  x.proximo;

3: FREE(x);

4: a.proximo  p;

7: end if

x

a p

inicio

(46)

LIST-DELETE(L,x)

2: p  x.proximo;

3: FREE(x);

4: a.proximo  p;

7: end if

a p

/

inicio

9 2 4 /

L

(47)

LIST-DELETE(L,x)

2: p  x.proximo;

3: FREE(x);

4: a.proximo  p;

7: end if

a p

inicio

(48)

• Cada nó pode ter até dois filhos

• Cada nó da árvore precisamos

▫ Ponteiro para o pai (p)

▫ Ponteiro para o filho da esquerda (e)

▫ Ponteiro para o filho da direita (d)

▫ Objeto ou chave (ch)

• Para a árvore precisamos

▫ 1 nó raíz

▫ n-1 nós

p e ch d

(49)

/

(50)

Análise de Algoritmos

(51)

• Como o nome sugere, trata-se de uma árvore binária otimizada para buscar seus elementos

• As chaves são sempre armazenadas segundo a propriedade abaixo

▫ Seja x um nó em uma árvore de pesquisa binária

▫ Se y é um nó da sub-árvore ESQUERDA de x, então y.chave  x.chave

(52)

/ 6

4

/ 2

/ 3 /

/ 5 / 10 /

/ 9 / / 8

(53)

TREE-PRINT(x)

1: if x  NIL then

2: TREE-PRINT(x.esquerda);

3: imprime x.chave;

4: TREE-PRINT(x.direita);

5: end if

2

4

7

(54)

TREE-PRINT(x)

1: if x  NIL then

2: TREE-PRINT(x.esquerda);

3: imprime x.chave;

4: TREE-PRINT(x.direita);

5: end if

Qual é o custo desta

operação?

(55)

TREE-SEARCH(x,k)

1: if x = NIL or k = x.chave then 2: return x;

3: end if

4: if k < x.chave then

5: return TREE-SEARCH(x.esquerda,k);

6: else

7: return TREE-SEARCH(x.direita,k);

5: end if

4

(56)

TREE-SEARCH(x,k)

1: if x = NIL or k = x.chave then 2: return x;

3: end if

4: if k < x.chave then

5: return TREE-SEARCH(x.esquerda,k);

6: else

7: return TREE-SEARCH(x.direita,k);

5: end if

Qual é o custo desta

operação?

(57)

TREE-MINIMUM(x)

1: while x.esquerda  NIL do 2: x  x.esquerda;

TREE-MAXIMUM(x)

Qual é o custo destas

operações?

(58)

TREE-SUCCESSOR(x)

1: if x.direita  NIL then

2: return TREE-MINIMUM(x.direita);

3: end if

4: y  x.pai;

5: while y  NIL and x = y.direita do 6: x  y;

7: y  y.pai;

8: end while 9: return y;

Qual é o funcionamento de TREE-SUCCESSOR(T.raiz) para a árvore T ao lado?

1

2

4

12

9

8

(59)

TREE-SUCCESSOR(x)

1: if x.direita  NIL then

2: return TREE-MINIMUM(x.direita);

3: end if

4: y  x.pai;

5: while y  NIL and x = y.direita do 6: x  y;

7: y  y.pai;

Qual é o custo

desta operação?

(60)

TREE-PREDECESSOR(x)

1: if x.esquerda  NIL then

2: return TREE-MAXIMUM(x.esquerda);

3: end if

4: y  x.pai;

5: while y  NIL and x = y.esquerda do 6: x  y;

7: y  y.pai;

(61)

TREE-INSERT(T,z) 1: y  NIL;

2: x  T.raiz;

3: while x  NIL do 4: y  x;

5: if z.chave < x.chave then 6: x  x.esquerda;

7: else

8: x  x.direita;

9: end while 10: z.pai  y;

11: if y = NIL then 12: T.raiz  z;

13: else

14: if z.chave < y.chave then

• Considere uma árvore sem elementos

• Insira os seguinte elementos em ordem

• 1, 2, 3, 4

• Insira os seguinte elementos em ordem

• 3, 4, 1, 2

(62)

• A remoção de um nó z considera três casos:

▫ z não possui filhos

▫ z possui apenas um filho

▫ z possui dois filhos

(63)

5

15

3 12

10 13

16

20

18 23

z

(64)

5

15

3 12

10

6

13

7

16

20

18 23

z

(65)

5

15

3 12

10 13

20

18 23

(66)

5

15

3 12

10

6

13

7

16

20

18 23

z

(67)

5

15

3 12

6 13

16

20

18 23

(68)

5

15

3 12

6 13

7

16

20

18 23

z

(69)

• Passo 1

▫ Remove o sucessor

▫ Guarda o sucessor

5

15

3 12

6 13

16

20

18 23

z

(70)

• Passo 1

▫ Remove o sucessor

▫ Guarda o sucessor

3

6 7 13 18 23

z

5

15

12

16

20

(71)

• Passo 1

▫ Remove o sucessor

▫ Guarda o sucessor

• Passo 2

▫ Substitui z pelo sucessor

5

15

3 12

6 13

16

20

18 23

z

(72)

• Passo 1

▫ Remove o sucessor

▫ Guarda o sucessor

• Passo 2

▫ Substitui z pelo sucessor

6

15

3 12

7 13

16

20

18 23

(73)

1. Escreva o ENQUEUE e o DEQUEUE para detectar o estouro negativo e o estouro positivo de uma fila

2. Descreva como implementar duas pilhas em um único arranjo (escreva os algoritmos)

▫

Nenhuma das pilhas sofre um estouro positivo a menos que o total de elementos nas duas pilhas juntas seja n

▫