O documento discute busca e ordenação de vetores. Explica busca linear e busca binária, definindo suas entradas, saídas e complexidades. A busca linear tem complexidade O(n), enquanto a busca binária é mais eficiente com complexidade O(log n).

1. Busca e Ordenação
Rodrigo
Rocha
1

2. Busca
2

3. 3

4. 3

5. 3

6. 3

7. Busca: definição
4

8. Busca: definição
Entrada:
4

9. Busca: definição
Entrada:
vetor x, com n elementos
4

10. Busca: definição
Entrada:
vetor x, com n elementos
elemento a ser buscado
4

11. Busca: definição
Entrada:
vetor x, com n elementos
elemento a ser buscado
Saída:
4

12. Busca: definição
Entrada:
vetor x, com n elementos
elemento a ser buscado
Saída:
índice (posição) do elemento no vetor
4

13. Busca: definição
Entrada:
vetor x, com n elementos
elemento a ser buscado
Saída:
índice (posição) do elemento no vetor
-1, se o elemento não for encontrado
4

14. Vetores
12 74 12 19 2223x =
5

15. Vetores
12 74 12 19 2223x =
n = 6 (quantidade de elementos no vetor x)
5

16. Vetores
12 74 12 19 2223x =
0 1 2 3 4 5
n = 6 (quantidade de elementos no vetor x)
índices
5

17. Vetores
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
n = 6 (quantidade de elementos no vetor x)
índices
índices
5

18. Vetores
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
n = 6 (quantidade de elementos no vetor x)
x[0] = 23 (primeiro elemento de x)
índices
índices
5

19. Vetores
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
n = 6 (quantidade de elementos no vetor x)
x[0] = 23 (primeiro elemento de x)
x[n-1] = 22 (último elemento de x)
índices
índices
5

20. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
6

21. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23)
6

22. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23) → 0
6

23. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23)
busca(x, 19)
→ 0
6

24. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23)
busca(x, 19)
→ 0
→ 4
6

25. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23)
busca(x, 19)
busca(x, 33)
→ 0
→ 4
6

26. Entrada/Saída
12 74 12 19 2223x =
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
busca(x, 23)
busca(x, 19)
busca(x, 33)
→ 0
→ 4
→ -1 (não encontrado)
6

27. Algoritmos
Busca linear
(ou busca sequencial)
Busca binária
7

28. Busca linear
8

29. Intuição
• Para cada elemento do vetor:
9

30. Intuição
• Para cada elemento do vetor:
• Compara com o elemento buscado
9

31. Intuição
• Para cada elemento do vetor:
• Compara com o elemento buscado
• Se o elemento for igual ao buscado,
retorna o índice do elemento
9

32. Algoritmo (em Python)
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

33. Algoritmo (em Python)
def buscaLinear(x, elem):
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

34. Algoritmo (em Python)
def buscaLinear(x, elem):
n = len(x)
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

35. Algoritmo (em Python)
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

36. Algoritmo (em Python)
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

37. Algoritmo (em Python)
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

38. Algoritmo (em Python)
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
def seq(start, stop, step=1):
dir = 1 if (step > 0) else -1
return range(start, stop + dir, step)
10

39. Complexidade
Complexidade de tempo
Complexidade de espaço
11

40. Complexidade
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
12

41. Complexidade
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
12

42. Complexidade
Melhor caso: 1 comparação (elem == x[0])
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
12

43. Complexidade
Melhor caso: 1 comparação (elem == x[0])
Pior caso: n comparações (elem não encontrado)
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
12

44. Complexidade
Melhor caso: 1 comparação (elem == x[0])
Pior caso: n comparações (elem não encontrado)
Caso médio: n/2 comparações
def buscaLinear(x, elem):
n = len(x)
for i in seq(0, n - 1): # 0, 1, ..., n-1
if x[i] == elem:
return i
return -1
12

45. Complexidade
13

46. Complexidade
• O tempo de execução da busca linear, no pior
caso, tende a ser proporcional ao número de
elementos, n.
13

47. Complexidade
• O tempo de execução da busca linear, no pior
caso, tende a ser proporcional ao número de
elementos, n.
• Em outras palavras, o tempo de execução é O(n).
13

48. Complexidade
• O tempo de execução da busca linear, no pior
caso, tende a ser proporcional ao número de
elementos, n.
• Em outras palavras, o tempo de execução é O(n).
• O espaço de armazenamento é constante, não
depende do tamanho do vetor.
13

49. Complexidade
• O tempo de execução da busca linear, no pior
caso, tende a ser proporcional ao número de
elementos, n.
• Em outras palavras, o tempo de execução é O(n).
• O espaço de armazenamento é constante, não
depende do tamanho do vetor.
• Em outras palavras, a complexidade de espaço é
O(1).
13

50. Discussão
Quantas comparações precisamos fazer,
no pior caso, para buscar um elemento
em uma lista de 1 milhão de elementos?
14

51. Discussão
15

52. Discussão
Vamos assumir que os elementos do vetor de 1
milhão de elementos estão em ordem crescente.
15

53. Discussão
Vamos assumir que os elementos do vetor de 1
milhão de elementos estão em ordem crescente.
É possível buscar um elemento com menos de 1
milhão comparações (no pior caso)?
15

54. Discussão
Vamos assumir que os elementos do vetor de 1
milhão de elementos estão em ordem crescente.
É possível buscar um elemento com menos de 1
milhão comparações (no pior caso)?
Como você busca uma palavra em um
dicionário?
15

55. Busca
16

56. Intuição
• Olhar o elemento do meio da lista
Ver animação interativa (buscar 67, 59, 60…)
17

57. Intuição
• Olhar o elemento do meio da lista
• Comparar com o elemento que estamos buscando
(<, >, =)
Ver animação interativa (buscar 67, 59, 60…)
17

58. Intuição
• Olhar o elemento do meio da lista
• Comparar com o elemento que estamos buscando
(<, >, =)
• Continuar procurando apenas na metade em que o
elemento pode estar
Ver animação interativa (buscar 67, 59, 60…)
17

59. Algoritmo
18

60. Algoritmo
def buscaBinaria(x, elem):
18

61. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
18

62. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
18

63. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
18

64. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
18

65. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
18

66. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
18

67. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
18

68. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
elif (elem < x[meio]):
18

69. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
elif (elem < x[meio]):
dir = meio - 1
18

70. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
elif (elem < x[meio]):
dir = meio - 1
else:
18

71. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
elif (elem < x[meio]):
dir = meio - 1
else:
esq = meio + 1
18

72. Algoritmo
def buscaBinaria(x, elem):
n = len(x)
esq = 0
dir = n - 1
while (esq <= dir):
meio = int((esq + dir) / 2)
if (x[meio] == elem):
return meio
elif (elem < x[meio]):
dir = meio - 1
else:
esq = meio + 1
return -1 18

73. Complexidade
19

74. Complexidade
0: n
19

75. Complexidade
0: n
1: n / 2
19

76. Complexidade
0: n
1: n / 2
2: n / 4
19

77. Complexidade
0: n
1: n / 2
2: n / 4
3: n / 8
19

78. Complexidade
0: n
1: n / 2
2: n / 4
3: n / 8
.
.
.
.
.
.
19

79. Complexidade
0: n
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
19

80. Complexidade
0: n n / 20
n / 21
n / 22
n / 23
n / 2k
=
=
=
=
=
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
19

81. Complexidade
0: n n / 20
n / 21
n / 22
n / 23
n / 2k
=
=
=
=
=
1 = n / 2k
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
19

82. Complexidade
0: n n / 20
n / 21
n / 22
n / 23
n / 2k
=
=
=
=
=
1 = n / 2k
2k = n
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
19

83. Complexidade
0: n n / 20
n / 21
n / 22
n / 23
n / 2k
=
=
=
=
=
1 = n / 2k
2k = n
k = log2(n)
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
19

84. Complexidade
0: n n / 20
n / 21
n / 22
n / 23
n / 2k
=
=
=
=
=
1 = n / 2k
2k = n
k = log2(n)
1: n / 2
2: n / 4
3: n / 8
k: 1
.
.
.
.
.
.
O(log n)
19

85. Confronto
20

86. n (tamanho do vetor)
tempo de
execução
busca linear
busca binária
Confronto
21

87. Confronto
22

88. Confronto
Entrada: vetor de 1 milhão de elementos
22

89. Confronto
Entrada: vetor de 1 milhão de elementos
Busca linear:
22

90. Confronto
Entrada: vetor de 1 milhão de elementos
Busca linear:
1 milhão de comparações
22

91. Confronto
Entrada: vetor de 1 milhão de elementos
Busca linear:
1 milhão de comparações
Busca binária:
22

92. Confronto
Entrada: vetor de 1 milhão de elementos
Busca linear:
1 milhão de comparações
Busca binária:
21 comparações
22

93. Confronto
Entrada: vetor de 1 milhão de elementos
Busca linear:
1 milhão de comparações
Busca binária:
21 comparações
E se fossem 2 milhões de elementos?
22

94. Discussão
23

95. Discussão
• Busca binária é mais rápida, mas requer vetor
ordenado
23

96. Discussão
• Busca binária é mais rápida, mas requer vetor
ordenado
• Se você pretende fazer muitas buscas no mesmo
vetor, pode valer a pena ordenar o vetor
23

97. Discussão
• Busca binária é mais rápida, mas requer vetor
ordenado
• Se você pretende fazer muitas buscas no mesmo
vetor, pode valer a pena ordenar o vetor
• Qual a complexidade de se ordenar um vetor?
23

98. Ordenação
24

99. 25

100. 26

101. Definição
27

102. Definição
Entrada:
27

103. Definição
Entrada:
vetor x, com n elementos
27

104. Definição
Entrada:
vetor x, com n elementos
Saída:
27

105. Definição
Entrada:
vetor x, com n elementos
Saída:
vetor x nos quais as posições dos elementos foram
trocadas de forma que
x[0] ≤ x[1] ≤ x[2] ≤ x[3] ≤ … ≤ x[n-1]
27

106. 28

107. 29

108. 30

109. 31

110. 32

111. 33

112. Comparar dois
elementos de cada vez
33

113. Comparar dois
elementos de cada vez
Trocar a posição
de dois elementos
33

114. ! % $ # @
34

115. ! %
$ # @
35

116. !
%
$ # @
36

117. !%
$ # @
37

118. !% $ # @
38

119. Para que estudar
algoritmos de ordenação?
• A maioria das linguagens já implementa algoritmos de
ordenação
39

120. Para que estudar
algoritmos de ordenação?
• A maioria das linguagens já implementa algoritmos de
ordenação
• Algoritmos de ordenação são bons objetos de estudo:
39

121. Para que estudar
algoritmos de ordenação?
• A maioria das linguagens já implementa algoritmos de
ordenação
• Algoritmos de ordenação são bons objetos de estudo:
• ordenação é um problema que já foi muito estudado
39

122. Para que estudar
algoritmos de ordenação?
• A maioria das linguagens já implementa algoritmos de
ordenação
• Algoritmos de ordenação são bons objetos de estudo:
• ordenação é um problema que já foi muito estudado
• os algoritmos apresentam dificuldade média
39

123. Para que estudar
algoritmos de ordenação?
• A maioria das linguagens já implementa algoritmos de
ordenação
• Algoritmos de ordenação são bons objetos de estudo:
• ordenação é um problema que já foi muito estudado
• os algoritmos apresentam dificuldade média
• eles podem ser usados como base para outros
algoritmos especializados
39

124. Algoritmos Estudados
Básicos
Selection Sort
Bubble Sort
Insertion Sort
Avançados
Merge Sort (intuição)
Quick Sort (intuição)
40

125. Algoritmos
Básicos
Selection Sort
Bubble Sort
Insertion Sort
41

126. Algoritmos Básicos
Incrementais
Ordenação in-place
Não são rápidos quando
há muitos elementos
42

127. Ordenação Incremental
43

128. Ordenação Incremental
43

129. Ordenação Incremental
43

130. Ordenação Incremental
43

131. Selection Sort
44

132. Selection Sort
• http://algoviz.org/OpenDSA/Books/OpenDSA/html/SelectionSort.html
45
@ # $ % &!
maior

133. Selection Sort
• http://algoviz.org/OpenDSA/Books/OpenDSA/html/SelectionSort.html
45
@ # $ % &!
maior

134. Selection Sort
• http://algoviz.org/OpenDSA/Books/OpenDSA/html/SelectionSort.html
45
@ # $ % &!
maior
@ & $ % #!
maior

135. Selection Sort
• http://algoviz.org/OpenDSA/Books/OpenDSA/html/SelectionSort.html
45
@ # $ % &!
maior
@ & $ % #!
maior

136. Selection Sort
• http://algoviz.org/OpenDSA/Books/OpenDSA/html/SelectionSort.html
45
@ # $ % &!
maior
@ & $ % #!
maior
@ & % $ #!
…

137. 12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
Algoritmo
46
ultimo

138. def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
imaior = indiceDoMaiorElemento(x, ultimo)
troca(x, imaior, ultimo)
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
Algoritmo
46
ultimo

139. def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
imaior = indiceDoMaiorElemento(x, ultimo)
troca(x, imaior, ultimo)
def indiceDoMaiorElemento(x, ultimo):
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
return imaior
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
Algoritmo
46
ultimo

140. def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
imaior = indiceDoMaiorElemento(x, ultimo)
troca(x, imaior, ultimo)
def indiceDoMaiorElemento(x, ultimo):
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
return imaior
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
Algoritmo
46
ultimo

141. Algoritmo
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
47

142. Algoritmo
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
47

143. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
48

144. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
48

145. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
quantidade de trocas (em qualquer caso): n - 1, que é O(n)
48

146. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
49

147. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
49

148. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
(n-1)
49

149. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
+(n-1) (n-2)
49

150. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
+(n-1) (n-2) + …
49

151. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
+(n-1) (n-2) + +… 2
49

152. Complexidade
def selectionSort(x):
n = len(x)
for ultimo in seq(n-1, 1, -1):
troca(x, imaior, ultimo)
imaior = 0
for i in seq(1, ultimo):
if x[i] > x[imaior]:
imaior = i
comparações:
(em qualquer caso)
+(n-1) (n-2) + + +… 2 1
49

153. Complexidade
comparações: +(n-1) (n-2) + + +… 2 1
(n - 1) parcelas
50

154. Complexidade
comparações: +(n-1)
(n-2) ++
+ …
2
1
(n-1)/2 pares
}
51

155. Complexidade
comparações: +(n-1)
(n-2) ++
+ …
2
1
(n-1)/2 pares
}
52

156. Complexidade
comparações: n
+
+ …
(n-1)/2 vezes
}n
53

157. Complexidade
comparações: n
+
+ …
(n-1)/2 vezes
}n
n (n-1)
2
———=
53

158. Complexidade
comparações: n
+
+ …
(n-1)/2 vezes
}n
n (n-1)
2
———=
= ½n² - ½n
53

159. Complexidade
comparações: n
+
+ …
(n-1)/2 vezes
}n
n (n-1)
2
———=
= ½n² - ½n
O(n²)
53

160. Complexidade
tempo gasto em comparações:
tempo gasto em trocas:
tempo total de execução é
~ ( ½n² - ½n )
~ ( n - 1 )
54

161. Complexidade
O(n²)
tempo gasto em comparações:
tempo gasto em trocas:
tempo total de execução é
~ ( ½n² - ½n )
~ ( n - 1 )
54

162. Bubble Sort
55

163. Intuição
Comparar cada
elemento com o próximo
http://algoviz.org/OpenDSA/Books/OpenDSA/html/BubbleSort.html56

164. Intuição
Comparar cada
elemento com o próximo
Se estiverem fora da
ordem, troca
http://algoviz.org/OpenDSA/Books/OpenDSA/html/BubbleSort.html56

165. Intuição
Comparar cada
elemento com o próximo
Se estiverem fora da
ordem, troca
Repete várias vezes até
o vetor ficar ordenado
http://algoviz.org/OpenDSA/Books/OpenDSA/html/BubbleSort.html56

166. Implementação 12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
57

167. Implementação
def bubbleSort(x):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
57

168. Implementação
def bubbleSort(x):
n = len(x)
for penultimo in seq(n-2, 0, -1):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
57

169. Complexidade
def bubbleSort(x):
n = len(x)
for penultimo in seq(n-2, 0, -1):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
58
otimização: flag

170. Complexidade
def bubbleSort(x):
n = len(x)
for penultimo in seq(n-2, 0, -1):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
58
otimização: flag

171. Complexidade
def bubbleSort(x):
n = len(x)
for penultimo in seq(n-2, 0, -1):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
comparações:
trocas: 0
O(n²)
O(n²)
O(n²)
pior
caso
melhor
caso
58
otimização: flag

172. Complexidade
def bubbleSort(x):
n = len(x)
for penultimo in seq(n-2, 0, -1):
for i in seq(0, penultimo):
if x[i] > x[i + 1]:
troca(x, i, i+1)
O(n²)
comparações:
trocas: 0
O(n²)
O(n²)
O(n²)
pior
caso
melhor
caso
58
otimização: flag

173. Curiosidade
https://www.youtube.com/watch?v=k4RRi_ntQc8
http://www.quora.com/What-is-the-most-efficient-way-to-sort-a-million-32-bit-integers
59

174. Insertion Sort
60

175. Intuição
61

176. Intuição
62

177. Intuição
63

178. Intuição
64

179. Intuição
65

180. Intuição
66

181. Intuição
67

182. Intuição
68

183. Intuição
68

184. Intuição
69

185. Intuição
70

186. Intuição
70

187. Intuição
>
70

188. Intuição
71

189. Intuição
71

190. Intuição
>
71

191. Intuição
72

192. Intuição
72

193. Intuição
>
72

194. Intuição
73

195. Intuição
73

196. Intuição
>
73

197. Intuição
73

198. Algoritmo
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
74
primeiro

199. Algoritmo
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
moveParaPosicaoCerta(x, primeiro)
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
74
primeiro

200. Algoritmo
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
moveParaPosicaoCerta(x, primeiro)
def moveParaPosicaoCerta(x, primeiro):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
74
primeiro

201. Algoritmo
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
moveParaPosicaoCerta(x, primeiro)
def moveParaPosicaoCerta(x, primeiro):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
74
primeiro

202. Algoritmo
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
def moveParaPosicaoCerta(x, primeiro):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
74
primeiro

203. def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
Algoritmo 12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
75

204. def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
Algoritmo 12 74 42 19 2223
0 1 2 3 4 5
n-6 n-5 n-4 n-3 n-2 n-1
75

205. Complexidade
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
76

206. Complexidade
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
76

207. Complexidade
def insertionSort(x):
n = len(x)
for primeiro in seq(1, n-1):
i = primeiro
while (i >= 1) and (x[i - 1] > x[i]):
troca(x, i - 1, i)
i = i - 1
comparações:
trocas: 0
O(n)
O(n²)
O(n²)
pior
caso
melhor
caso
O(n²)
76

208. Discussão
E se usarmos busca binária para encontrar a
posição de inserção de cada elemento?
77

209. Confronto
78

210. Complexidade
• Todos os algoritmos possuem tempo de execução
O(n2) no pior caso
• Todos os algoritmos usam O(1) de espaço
79

211. https://vinayakgarg.wordpress.com/2011/10/25/time-comparison-of-quick-sort-insertion-sort-and-bubble-sort/
Benchmark
80

212. https://vinayakgarg.wordpress.com/2011/10/25/time-comparison-of-quick-sort-insertion-sort-and-bubble-sort/
Benchmark
80

213. Algoritmos
Avançados
Merge Sort
Quick Sort
81

214. Algoritmos Avançados
Dividir para conquistar
82

215. Algoritmos Avançados
Dividir para conquistar
Rápidos para vetores grandes
82

216. Algoritmos Avançados
Dividir para conquistar
Rápidos para vetores grandes
82

217. Merge Sort
83

218. Intuição
• Combinar dois vetores ordenados em um grande
vetor ordenado é rápido
http://algoviz.org/OpenDSA/Books/OpenDSA/html/Mergesort.html
84

219. Intuição
• Combinar dois vetores ordenados em um grande
vetor ordenado é rápido
http://algoviz.org/OpenDSA/Books/OpenDSA/html/Mergesort.html
84

220. Intuição
85

221. Intuição
• Um vetor com um elemento está sempre ordenado
85

222. Intuição
• Um vetor com um elemento está sempre ordenado
• Merge sort: dividir-para-conquistar
85

223. Intuição
• Um vetor com um elemento está sempre ordenado
• Merge sort: dividir-para-conquistar
• Dividir vetor no meio sucessivamente
até restarem só sub-vetores de um elemento
85

224. Intuição
• Um vetor com um elemento está sempre ordenado
• Merge sort: dividir-para-conquistar
• Dividir vetor no meio sucessivamente
até restarem só sub-vetores de um elemento
• Combinar dois vetores em vetor maior
85

225. Intuição
http://algoviz.org/OpenDSA/Books/OpenDSA/html/Mergesort.html
86

226. Algoritmo (ideia geral)
def mergeSort(x):
n = len(x)
mergeSortAux(x, 0, n - 1)
def mergeSortAux(x, inicio, final):
if final > inicio:
meio = int((inicio + final) / 2)
mergeSortAux(x, inicio, meio)
mergeSortAux(x, meio+1, final)
combinar(x, inicio, meio, final)
87

227. Complexidade
combinar:
n comparações
n/2 elementos n/2 elementos
n elementos
88

228. Complexidade
n
n / 2 n / 2
n / 4
1 …………………………..
n / 4 n / 4 n / 4
1 1 1
…
…
…
…
…
…
…
…
…
…
…
…
n comparações
n/2 comparações n/2 comparações
log2(n)
n log2(n)
n
+ n
n
…
+
+
+
……………… =
…… =
… =
89

229. Complexidade
Tempo de execução: O(n log2(n))
O(n log2(n)) < O(n2)
Para vetores muito pequenos, pode ser mais lento que os algoritmos básicos
90

230. Complexidade
Merge sort não é in-place:
Uma boa implementação usa espaço adicional
para n elementos
Complexidade de espaço: O(n)
91

231. Quick Sort
92

232. Intuição
Escolhe um elemento (chamaremos de pivô)
93

233. Intuição
Escolhe um elemento (chamaremos de pivô)
Coloca todos os elementos menores que o pivô à
esquerda dele
93

234. Intuição
Escolhe um elemento (chamaremos de pivô)
Coloca todos os elementos menores que o pivô à
esquerda dele
Coloca todos os elementos maiores que o pivô à
direita dele
93

235. Intuição
Escolhe um elemento (chamaremos de pivô)
Coloca todos os elementos menores que o pivô à
esquerda dele
Coloca todos os elementos maiores que o pivô à
direita dele
Repete para o sub-vetor à esquerda do pivô
e para o sub-vetor à direita do pivô
93

236. Intuição
19 74 12 38 2223
94

237. Intuição
19 74 12 38
22
23
95

238. Intuição
19 74 12 38
22 23
96

239. Intuição
19
74 12 38
22 23
97

240. Intuição
19 74
12 38
22 23
98

241. Intuição
19 7412
38
22 23
99

242. Intuição
19 7412 382322
100

243. Intuição
19 7412 382322
101

244. Intuição
19 74
12
382322
102

245. Intuição
19
74
12
382322
103

246. Intuição
19 7412 382322
104

247. Intuição
19 7412 382322
105

248. Intuição
19 7412 382322
106

249. Intuição
19 7412
38
2322
107

250. Intuição
19 7412
3823
22
108

251. Intuição
19
74
12
3823
22
109

252. Intuição
19 7412 2322 38
110

253. Intuição
19 7412 2322 38
111

254. Algoritmo
• O quick sort não usa memória adicional
• Ver http://algoviz.org/OpenDSA/Books/OpenDSA/
html/Quicksort.html
112

255. Complexidade
• Melhor caso: se o pivô for sempre a mediana (valor
que divide o vetor em duas partes iguais), a
complexidade será a mesma do merge sort:
O(n log(n))
113

256. Complexidade
• Melhor caso: se o pivô for sempre a mediana (valor
que divide o vetor em duas partes iguais), a
complexidade será a mesma do merge sort:
O(n log(n))
• Pior caso: se o pivô for sempre o máximo ou o
mínimo, a complexidade será a mesma dos
algoritmos incrementais:
O(n2)
113

257. Complexidade
• Melhor caso: se o pivô for sempre a mediana (valor
que divide o vetor em duas partes iguais), a
complexidade será a mesma do merge sort:
O(n log(n))
• Pior caso: se o pivô for sempre o máximo ou o
mínimo, a complexidade será a mesma dos
algoritmos incrementais:
O(n2)
• Caso médio: O(n log(n))
113

258. Confronto
114

259. Confronto
Na prática, na maioria das vezes o quick sort é mais
rápido do que o merge sort
115

260. Confronto
Na prática, na maioria das vezes o quick sort é mais
rápido do que o merge sort
Eventualmente o quick sort pode cair no pior caso
115

261. Discussão
116

262. Discussão
Para vetores muito pequenos, os algoritmos básicos
são mais rápidos do que os avançados
116

263. Discussão
Para vetores muito pequenos, os algoritmos básicos
são mais rápidos do que os avançados
Abordagem híbrida: usar quick sort para dividir
sucessivamente o vetor em sub-vetores. Quando o
sub-vetor for pequeno o suficiente, ordenar com
insertion sort
116

264. Tópicos Avançados
• Ordenação não-baseada em comparações
• Algoritmos distribuídos
• Ordenação em listas encadeadas
117

265. Busca e Ordenação
Sites:
https://pt.khanacademy.org/computing/computer-science/algorithms
http://algoviz.org/OpenDSA/Books/OpenDSA/html/index.html
http://www.sorting-algorithms.com/
Livros:
Estrutura de Dados, de Ascencio e Araújo
Algoritmos, de Cormen, Leiserson, Rivest e Stein
CS Unplugged, de Bell, Witten e Fellows (http://csunplugged.org/)
118