algoritmos em linguagem c - ime-usppf/algoritmos-livro/slides/... · 2013. 4. 30. ·...
TRANSCRIPT
![Page 1: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/1.jpg)
ALGORITMOSem linguagem C
Paulo Feofiloff
Instituto de Matemática e EstatísticaUniversidade de São Paulo
Campus/Elsevier
.
![Page 2: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/2.jpg)
“Algoritmos em linguagem C”Paulo Feofiloff
editora Campus/Elsevier, 2009
www.ime.usp.br/~pf/algoritmos-livro/
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 2 / 162
![Page 3: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/3.jpg)
“Ciência da computação não é a ciência dos computadores,assim como a astronomia não é a ciência dos telescópios.”
— E. W. Dijkstra
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 3 / 162
![Page 4: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/4.jpg)
Leiaute
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 4 / 162
![Page 5: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/5.jpg)
Leiaute Bom
Bom leiauteint Funcao (int n, int v[]) {
int i, j;i = 0;while (i < n) {
if (v[i] != 0)i = i + 1;
else {for (j = i + 1; j < n; j++)
v[j-1] = v[j];n = n - 1;
}}return n;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 5 / 162
![Page 6: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/6.jpg)
Leiaute Mau
Mau leiaute
int Funcao (int n, int v[]) {int i, j;i = 0;while (i < n) {
if (v[i] != 0)i = i + 1;
else {for (j = i + 1; j < n; j++)
v[j-1] = v[j];n = n - 1;
}}return n;
}
Use fonte de espaçamento fixo!
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 6 / 162
![Page 7: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/7.jpg)
Leiaute Mau
Péssimo leiaute
int Funcao ( int n,int v[] ){int i,j;i=0;while(i<n){
if(v[i] !=0)i= i +1;
else{
for (j=i+1;j<n;j++)v[j-1]=v[j];
n =n- 1;}
}return n;
}
Seja consistente!
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 7 / 162
![Page 8: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/8.jpg)
Leiaute Compacto
Um bom leiaute compacto
int Funcao (int n, int v[]) {int i, j;i = 0;while (i < n) {
if (v[i] != 0) i = i + 1;else {
for (j = i + 1; j < n; j++) v[j-1] = v[j];n = n - 1; } }
return n; }
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 8 / 162
![Page 9: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/9.jpg)
Leiaute Regras
Regras
Use as regras adotadas por todos os jornais, revistas e livros:
bla bla bla
bla = bla
bla <= bla
bla; bla
bla) bla;
bla {
while (bla
if (bla
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 9 / 162
![Page 10: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/10.jpg)
Leiaute Enfeitado
Leiaute enfeitadoint Função (int n, int v[]) {
int i, j;i = 0;while (i < n) {
if (v[i] != 0)i = i + 1;
else {for (j = i + 1; j < n; j++)
v[j-1] = v[j];n = n - 1;
}}return n;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 10 / 162
![Page 11: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/11.jpg)
Leiaute O que eles dizem
“ Devemos mudar nossa atitude tradicional em relação à construção de programas.Em vez de imaginar que nossa principal tarefa
é instruir o computador sobre o que ele deve fazer,vamos imaginar que nossa principal tarefa é
explicar a seres humanos o que queremos que o computador faça.”— D. E. Knuth
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 11 / 162
![Page 12: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/12.jpg)
Documentação
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 12 / 162
![Page 13: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/13.jpg)
Documentação O que versus como
I documentação: o que um algoritmo fazI código: como o algoritmo faz o que faz
Exemplo
/* A função abaixo recebe um número n >= 1 e um vetor v* e devolve o valor de um elemento máximo de v[0..n-1].******************************************************/
int Max (int v[], int n) {int j, x = v[0];for (j = 1; j < n; j++)
if (x < v[j]) x = v[j];return x;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 13 / 162
![Page 14: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/14.jpg)
Invariantes
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 14 / 162
![Page 15: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/15.jpg)
Invariantes Explicam processo iterativo
Exemplo 1
int Max (int v[], int n) {int j, x;x = v[0];for (j = 1; j < n; j++)
/* x é um elemento máximo de v[0..j-1] */if (x < v[j]) x = v[j];
return x;}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 15 / 162
![Page 16: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/16.jpg)
Invariantes Explicam processo iterativo
Exemplo 2
int Max (int v[], int n) {int j, x;x = v[0];for (j = 1; /* A */ j < n; j++)
if (x < v[j]) x = v[j];return x;
}
/* a cada passagem pelo ponto A,x é um elemento máximo de v[0..j-1] */
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 16 / 162
![Page 17: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/17.jpg)
Invariantes O que eles dizem
“A atividade de programação deve ser encaradacomo um processo de criação de obras de literatura,
escritas para serem lidas.”— D. E. Knuth
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 17 / 162
![Page 18: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/18.jpg)
Recursão
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 18 / 162
![Page 19: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/19.jpg)
Recursão
“Para entender recursão,é preciso primeiro entender recursão.”
— folclore
“Ao tentar resolver o problema,encontrei obstáculos dentro de obstáculos.
Por isso, adotei uma solução recursiva.”— um aluno
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 19 / 162
![Page 20: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/20.jpg)
Recursão Instâncias de problemas
Problemas e suas instâncias
I instância de um problema = exemplo concreto do problemaI cada conjunto de dados de um problema define uma instânciaI cada instância tem um tamanho
Exemplo
Problema: Calcular a média de dois números, digamos a e b.Instância: Calcular a média de 123 e 9876.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 20 / 162
![Page 21: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/21.jpg)
Recursão Algoritmos recursivos
Problemas que têm estrutura recursiva
Cada instância do problemacontém uma instância menor do mesmo problema.
Algoritmo recursivo
se a instância em questão é pequenaresolva-a diretamente
senãoreduza-a a uma instância menor do mesmo problemaaplique o método à instância menorvolte à instância original
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 21 / 162
![Page 22: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/22.jpg)
Recursão Exemplo
Exemplo: Problema do máximo
Determinar o valor de um elemento máximo de um vetor v[0 . . n−1].
I o tamanho de uma instância deste problema é n
I o problema só faz sentido quando n ≥ 1
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 22 / 162
![Page 23: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/23.jpg)
Recursão Exemplo
Solução recursiva/* Ao receber v e n >= 1, esta função devolve
o valor de um elemento máximo de v[0..n-1]. */
int MáximoR (int v[], int n) {if (n == 1)
return v[0];else {
int x;x = MáximoR (v, n - 1);if (x > v[n-1])
return x;else
return v[n-1];}
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 23 / 162
![Page 24: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/24.jpg)
Recursão Exemplo
Outra solução recursivaint Máximo (int v[], int n) {
return MaxR (v, 0, n);}
int MaxR (int v[], int i, int n) {if (i == n-1) return v[i];else {
int x;x = MaxR (v, i + 1, n);if (x > v[i]) return x;else return v[i];
}}
/* A função MaxR recebe v, i e n tais que i < ne devolve o valor de um elemento máximo de v[i..n-1]. */
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 24 / 162
![Page 25: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/25.jpg)
Vetores
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 25 / 162
![Page 26: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/26.jpg)
Vetores Busca
Problema da buscaDado x e vetor v[0 . . n−1], encontrar um índice k tal que v[k] = x.
x 987
0 n−1
v 222 555 111 333 444 666 555 888 777 987 654
I o problema faz sentido com qualquer n ≥ 0I se n = 0, o vetor é vazio e essa instância não tem soluçãoI como indicar que não há solução?
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 26 / 162
![Page 27: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/27.jpg)
Vetores Busca
Algoritmo de buscaRecebe um número x e um vetor v[0 . . n−1] com n ≥ 0e devolve k no intervalo 0 . . n−1 tal que v[k] = x.Se tal k não existe, devolve −1.
int Busca (int x, int v[], int n) {int k;k = n - 1;while (k >= 0 && v[k] != x)
k -= 1;return k;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 27 / 162
![Page 28: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/28.jpg)
Vetores Busca
Deselegante e/ou ineficiente!
int k = n - 1, achou = 0;while (k >= 0 && achou == 0) {
if (v[k] == x) achou = 1;else k -= 1;
}return k;
int k;if (n == 0) return -1;k = n - 1;while (k >= 0 && v[k] != x) k -= 1;return k;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 28 / 162
![Page 29: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/29.jpg)
Vetores Busca
Deselegante, ineficiente e/ou errado!
int k = 0;int sol = -1;for (k = n-1; k >= 0; k--)
if (v[k] == x) sol = k;return sol;
int k = n - 1;while (v[k] != x && k >= 0)
k -= 1;return k;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 29 / 162
![Page 30: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/30.jpg)
Vetores Busca
Algoritmo recursivo de buscaRecebe x, v e n ≥ 0 e devolve k tal que 0 ≤ k < n e v[k] = x.Se tal k não existe, devolve −1.
int BuscaR (int x, int v[], int n) {if (n == 0) return -1;if (x == v[n-1]) return n - 1;return BuscaR (x, v, n - 1);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 30 / 162
![Page 31: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/31.jpg)
Vetores Busca
Deselegante!
int feio (int x, int v[], int n) {if (n == 1) {
if (x == v[0]) return 0;else return -1;
}if (x == v[n-1]) return n - 1;return feio (x, v, n - 1);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 31 / 162
![Page 32: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/32.jpg)
Vetores Remoção
Problema de remoçãoRemover o elemento de índice k de um vetor v[0 . . n−1].
Decisões de projeto:I suporemos 0 ≤ k ≤ n− 1I novo vetor fica em v[0 . . n−2]I algoritmo devolve algo?
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 32 / 162
![Page 33: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/33.jpg)
Vetores Remoção
Algoritmo de remoçãoRemove o elemento de índice k do vetor v[0 . . n−1]e devolve o novo valor de n. Supõe 0 ≤ k < n.
int Remove (int k, int v[], int n) {int j;for (j = k; j < n-1; j++)
v[j] = v[j+1];return n - 1;
}
I funciona bem mesmo quando k = n− 1 ou k = 0
I exemplo de uso: n = Remove (51, v, n);
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 33 / 162
![Page 34: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/34.jpg)
Vetores Remoção
Versão recursivaint RemoveR (int k, int v[], int n) {
if (k == n-1) return n - 1;else {
v[k] = v[k+1];return RemoveR (k + 1, v, n);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 34 / 162
![Page 35: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/35.jpg)
Vetores Inserção
Problema de inserçãoInserir um novo elemento y entre as posições k − 1 e kde um vetor v[0 . . n−1].
Decisões de projeto:I se k = 0 então insere no inícioI se k = n então insere no fimI novo vetor fica em v[0 . . n+1]
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 35 / 162
![Page 36: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/36.jpg)
Vetores Inserção
Algoritmo de inserçãoInsere y entre as posições k − 1 e k do vetor v[0 . . n−1]e devolve o novo valor de n. Supõe que 0 ≤ k ≤ n.
int Insere (int k, int y, int v[], int n) {int j;for (j = n; j > k; j--)
v[j] = v[j-1];v[k] = y;return n + 1;
}
I estamos supondo n < N
I exemplo de uso: n = Insere (51, 999, v, n);
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 36 / 162
![Page 37: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/37.jpg)
Vetores Inserção
Versão recursivaint InsereR (int k, int y, int v[], int n) {
if (k == n) v[n] = y;else {
v[n] = v[n-1];InsereR (k, y, v, n - 1);
}return n + 1;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 37 / 162
![Page 38: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/38.jpg)
Vetores Busca seguida de remoção
Problema de busca-e-remoçãoRemover todos os elementos nulos de um vetor v[0 . . n−1].
AlgoritmoRemove todos os elementos nulos de v[0 . . n−1],deixa o resultado em v[0 . . i−1], e devolve o valor de i.
int RemoveZeros (int v[], int n) {int i = 0, j;for (j = 0; j < n; j++)
if (v[j] != 0) {v[i] = v[j];i += 1;
}return i;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 38 / 162
![Page 39: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/39.jpg)
Vetores Busca seguida de remoção
Funciona bem mesmo em casos extremos:
I quando n vale 0
I quando v[0 . . n−1] não tem zeros
I quando v[0 . . n−1] só tem zeros
InvariantesNo início de cada iteração
I i ≤ j
I v[0 . . i−1] é o resultado da remoção dos zerosdo vetor v[0 . . j−1] original
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 39 / 162
![Page 40: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/40.jpg)
Vetores Busca seguida de remoção
Mau exemplo: deselegante e ineficiente
int i = 0, j = 0; /* "j = 0" é supérfluo */while (i < n) {
if (v[i] != 0) i += 1;else {
for (j = i; j+1 < n; j++) /* ineficiente */v[j] = v[j+1]; /* ineficiente */
--n;}
}return n;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 40 / 162
![Page 41: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/41.jpg)
Vetores Busca seguida de remoção
Versão recursivaint RemoveZerosR (int v[], int n) {
int m;if (n == 0) return 0;m = RemoveZerosR (v, n - 1);if (v[n-1] == 0) return m;v[m] = v[n-1];return m + 1;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 41 / 162
![Page 42: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/42.jpg)
Endereçose ponteiros
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 42 / 162
![Page 43: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/43.jpg)
Endereços e ponteiros Endereços
Endereços
I os bytes da memória são numerados seqüencialmenteI o número de um byte é o seu endereçoI cada char ocupa 1 byteI cada int ocupa 4 bytes consecutivosI etc.I cada objeto — char, int, struct etc. — tem um endereçoI o endereço de um objeto x é &x
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 43 / 162
![Page 44: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/44.jpg)
Endereços e ponteiros Endereços
Exemplo fictício
char c;int i;struct {int x, y;} ponto;int v[4];
endereços
c 89421i 89422ponto 89426v[0] 89434v[1] 89438v[2] 89442
I &i vale 89422I &v[3] vale 89446
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 44 / 162
![Page 45: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/45.jpg)
Endereços e ponteiros Ponteiros
Ponteiros
I ponteiro é um tipo de variável capaz de armazenar endereçosI se p = &x então dizemos “p aponta para x”I se p é um ponteiro então *p é o valor do objeto apontado por p
89422
60001
−999989422
r -
p−9999
representação esquemática
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 45 / 162
![Page 46: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/46.jpg)
Endereços e ponteiros Ponteiros
Exemplo: Um jeito bobo de fazer j = i + 999
int j, i = 888;int *p;p = &i;j = *p + 999;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 46 / 162
![Page 47: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/47.jpg)
Listasencadeadas
999 r - 999 r - 999 r - 999 r - 999 r - 999 r
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 47 / 162
![Page 48: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/48.jpg)
Listas encadeadas Estrutura da lista
Estrutura de uma célulastruct cel {
int conteúdo;struct cel *seg; /* seguinte */
};
999 r -conteúdo seg
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 48 / 162
![Page 49: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/49.jpg)
Listas encadeadas Estrutura da lista
Células são um novo tipo de dados
typedef struct cel célula;
Definição de uma célula e de um ponteiro para célulacélula c;célula *p;
I conteúdo da célula:c.conteúdop->conteúdo
I endereço da célula seguinte:c.segp->seg
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 49 / 162
![Page 50: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/50.jpg)
Listas encadeadas Estrutura da lista
999 r - 999 r - 999 r - 999 r - 999 r - 999 rúltima célula da lista: p->seg vale NULL
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 50 / 162
![Page 51: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/51.jpg)
Listas encadeadas Estrutura da lista
Exemplos: imprime lista com e sem cabeçaO algoritmo imprime o conteúdo de uma lista lst sem cabeça.
void Imprima (célula *lst) {célula *p;for (p = lst; p != NULL; p = p->seg)
printf ("%d\n", p->conteúdo);}
Imprime o conteúdo de uma lista lst com cabeça.
void Imprima (célula *lst) {célula *p;for (p = lst->seg; p != NULL; p = p->seg)
printf ("%d\n", p->conteúdo);}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 51 / 162
![Page 52: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/52.jpg)
Listas encadeadas Busca
Algoritmo de buscaRecebe um inteiro x e uma lista lst com cabeça.Devolve o endereço de uma célula que contém xou devolve NULL se tal célula não existe.
célula *Busca (int x, célula *lst) {célula *p;p = lst->seg;while (p != NULL && p->conteúdo != x)
p = p->seg;return p;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 52 / 162
![Page 53: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/53.jpg)
Listas encadeadas Busca
Versão recursiva
célula *BuscaR (int x, célula *lst) {if (lst->seg == NULL)
return NULL;if (lst->seg->conteúdo == x)
return lst->seg;return BuscaR (x, lst->seg);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 53 / 162
![Page 54: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/54.jpg)
Listas encadeadas Remoção
Algoritmo de remoção de uma célulaRecebe o endereço p de uma célula em uma listae remove da lista a célula p->seg.Supõe que p 6= NULL e p->seg 6= NULL.
void Remove (célula *p) {célula *lixo;lixo = p->seg;p->seg = lixo->seg;free (lixo);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 54 / 162
![Page 55: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/55.jpg)
Listas encadeadas Inserção
Algoritmo de inserção de nova célulaInsere uma nova célula em uma listaentre a célula p e a seguinte (supõe p 6= NULL).A nova célula terá conteúdo y.
void Insere (int y, célula *p) {célula *nova;nova = malloc (sizeof (célula));nova->conteúdo = y;nova->seg = p->seg;p->seg = nova;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 55 / 162
![Page 56: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/56.jpg)
Listas encadeadas Busca e remoção
Algoritmo de busca seguida de remoçãoRecebe uma lista lst com cabeçae remove da lista a primeira célula que contiver x,se tal célula existir.
void BuscaERemove (int x, célula *lst) {célula *p, *q;p = lst;q = lst->seg;while (q != NULL && q->conteúdo != x) {
p = q;q = q->seg;
}if (q != NULL) {
p->seg = q->seg;free (q);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 56 / 162
![Page 57: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/57.jpg)
Listas encadeadas Busca e inserção
Algoritmo de busca seguida de inserçãoRecebe lista lst com cabeça e insere nova célula conteúdo yimediatamente antes da primeira que contiver x.Se nenhuma célula contiver x, a nova célula será inserida no fim da lista.
void BuscaEInsere (int y, int x, célula *lst) {célula *p, *q, *nova;nova = malloc (sizeof (célula));nova->conteúdo = y;p = lst;q = lst->seg;while (q != NULL && q->conteúdo != x) {
p = q;q = q->seg;
}nova->seg = q;p->seg = nova;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 57 / 162
![Page 58: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/58.jpg)
Filas
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 58 / 162
![Page 59: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/59.jpg)
Filas Implementação em vetor
Fila implementada em vetor
0 s t N-1111 222 333 444 555 666
uma fila f[s..t-1]
Remove elemento da filax = f[s++]; /* x = f[s]; s += 1; */
Insere y na fila
f[t++] = y; /* f[t] = y; t += 1; */
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 59 / 162
![Page 60: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/60.jpg)
Filas Distâncias em uma rede
Aplicação: distâncias em uma rede
0 1 2 3 4 5
0 0 1 0 0 0 01 0 0 1 0 0 02 0 0 0 0 1 03 0 0 1 0 1 04 1 0 0 0 0 05 0 1 0 0 0 0
s ss
ss s
5 0
1
4
2 3
@@R@@
?
�
-6�@@I
@@
0 1 2 3 4 5
d 2 3 1 0 1 6
O vetor d dá as distâncias da cidade 3 a cada uma das demais.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 60 / 162
![Page 61: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/61.jpg)
Filas Distâncias em uma rede
Algoritmo das distânciasRecebe matriz A que representa as interligações entre cidades 0, 1, . . . , n− 1:há uma estrada de x a y se e somente se A[x][y] = 1.Devolve um vetor d tal que d[x] é a distância da cidade o à cidade x.
int *Distâncias (int **A, int n, int o) {int *d, x, y;int *f, s, t;d = malloc (n * sizeof (int));for (x = 0; x < n; x++) d[x] = -1;d[o] = 0;f = malloc (n * sizeof (int));processo iterativofree (f);return d;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 61 / 162
![Page 62: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/62.jpg)
Filas Distâncias em uma rede
processo iterativo
s = 0; t = 1; f[s] = o; /* o entra na fila */while (s < t) {
x = f[s++]; /* x sai da fila */for (y = 0; y < n; y++)
if (A[x][y] == 1 && d[y] == -1) {d[y] = d[x] + 1;f[t++] = y; /* y entra na fila */
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 62 / 162
![Page 63: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/63.jpg)
Filas Distâncias em uma rede
Invariantes (antes de cada comparação “s < t”)
1. para cada cidade v em f[0 . . t−1]existe um caminho de comprimento d[v] de o a vcujas cidades estão todas em f[0 . . t−1]
2. para cada cidade v de f[0 . . t−1]todo caminho de o a v tem comprimento ≥ d[v]
3. toda estrada que começa em f[0 . . s−1] termina em f[0 . . t−1]
Conseqüência
Para cada v em f[0 . . t−1], o número d[v] é a distância de o a v.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 63 / 162
![Page 64: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/64.jpg)
Filas Distâncias em uma rede
Para provar invariantes 1 a 3, precisamos de mais dois invariantes:
4. d[f[s]] ≤ d[f[s+1]] ≤ · · · ≤ d[f[t−1]]
5. d[f[t−1]] ≤ d[f[s]] + 1
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 64 / 162
![Page 65: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/65.jpg)
Filas Implementação circular
Implementação circular da fila
0 t s N-1444 555 666 111 222 333
uma fila f[s..t-1]
Remove elemento da filax = f[s++];if (s == N) s = 0;
Insere y na fila
f[t++] = y;if (t == N) t = 0;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 65 / 162
![Page 66: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/66.jpg)
Filas Implementação em lista encadeada
Fila implementada em lista encadeada
typedef struct cel {int valor;struct cel *seg;
} célula;
Decisões de projeto
I lista sem cabeça
I primeira célula: início da fila
I última célula: fim da fila
Fila vaziacélula *s, *t; /* s aponta primeiro elemento da fila */s = t = NULL; /* t aponta último elemento da fila */
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 66 / 162
![Page 67: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/67.jpg)
Filas Implementação em lista encadeada
Remove elemento da filaRecebe endereços es e et das variáveis s e t respectivamente.Supõe que fila não está vazia e remove um elemento da fila.Devolve o elemento removido.
int Remove (célula **es, célula **et) {célula *p;int x;p = *es;/* p aponta o primeiro elemento da fila */x = p->valor;*es = p->seg;free (p);if (*es == NULL) *et = NULL;return x;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 67 / 162
![Page 68: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/68.jpg)
Filas Implementação em lista encadeada
Insere elemento na filaRecebe endereços es e et das variáveis s e t respectivamente.Insere um novo elemento com valor y na fila.Atualiza os valores de s e t.
void Insere (int y, célula **es, célula **et) {célula *nova;nova = malloc (sizeof (célula));nova->valor = y;nova->seg = NULL;if (*et == NULL) *et = *es = nova;else {
(*et)->seg = nova;*et = nova;
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 68 / 162
![Page 69: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/69.jpg)
Pilhas
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 69 / 162
![Page 70: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/70.jpg)
Pilhas Implementação em vetor
Pilha implementada em vetor
0 t N-1111 222 333 444 555 666 777
uma pilha p[0..t-1]
Remove elemento da pilha
x = p[--t]; /* t -= 1; x = p[t]; */
Insere y na pilha
p[t++] = y; /* p[t] = y; t += 1; */
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 70 / 162
![Page 71: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/71.jpg)
Pilhas Parênteses e chaves
Aplicação: parênteses e chavesI expressao bem-formada: ((){()})I expressao malformada: ({)}
AlgoritmoDevolve 1 se a string s contém uma seqüência bem-formadae devolve 0 em caso contrário.
int BemFormada (char s[]) {char *p; int t;int n, i;n = strlen (s);p = malloc (n * sizeof (char));processo iterativofree (p);return t == 0;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 71 / 162
![Page 72: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/72.jpg)
Pilhas Parênteses e chaves
processo iterativo
t = 0;for (i = 0; s[i] != ’\0’; i++) {
/* p[0..t-1] é uma pilha */switch (s[i]) {
case ’)’: if (t != 0 && p[t-1] == ’(’) --t;else return 0;break;
case ’}’: if (t != 0 && p[t-1] == ’{’) --t;else return 0;break;
default: p[t++] = s[i];}
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 72 / 162
![Page 73: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/73.jpg)
Pilhas Notação posfixa
Aplicação: notação posfixa
Notação infixa versus posfixa
infixa posfixa
( A + B * C ) A B C * +
( A * ( B + C ) / D - E ) A B C + * D / E -
( A + B * ( C - D * ( E - F ) - G * H ) - I * 3 ) A B C D E F - * - G H * - * + I 3 * -
( A + B * C / D * E - F ) A B C * D / E * + F -
( A * ( B + ( C * ( D + ( E * ( F + G ) ) ) ) ) ) A B C D E F G + * + * + *
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 73 / 162
![Page 74: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/74.jpg)
Pilhas Notação posfixa
AlgoritmoRecebe uma expressão infixa representada por uma string infixque começa com ’(’ e termina com ’)’ seguido de ’\0’.Devolve a correspondente expressão posfixa.
char *InfixaParaPosfixa (char infix[]) {char *posfix, x;char *p; int t;int n, i, j;n = strlen (infix);posfix = malloc (n * sizeof (char));p = malloc (n * sizeof (char));processo iterativofree (p);posfix[j] = ’\0’;return posfix;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 74 / 162
![Page 75: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/75.jpg)
Pilhas Notação posfixa
processo iterativo
t = 0; p[t++] = infix[0]; /* empilha ’(’ */for (j = 0, i = 1; /*X*/ infix[i] != ’\0’; i++) {
/* p[0..t-1] é uma pilha de caracteres */switch (infix[i]) {
case ’(’: p[t++] = infix[i]; /* empilha */break;
case ’)’: while (1) { /* desempilha */x = p[--t];if (x == ’(’) break;posfix[j++] = x; }
break;
demais casos}
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 75 / 162
![Page 76: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/76.jpg)
Pilhas Notação posfixa
demais casoscase ’+’:case ’-’: while (1) {
x = p[t-1];if (x == ’(’) break;--t; /* desempilha */posfix[j++] = x; }
p[t++] = infix[i]; /* empilha */break;
case ’*’:case ’/’: while (1) {
x = p[t-1];if (x == ’(’ || x == ’+’ || x == ’-’)
break;--t;posfix[j++] = x; }
p[t++] = infix[i];break;
default: posfix[j++] = infix[i];
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 76 / 162
![Page 77: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/77.jpg)
Pilhas Notação posfixa
Aplicação de InfixaParaPosfixa à expressão (A*(B*C+D))
Valores das variáveis a cada passagem pelo ponto X:
infix[0..i-1] p[0..t-1] posfix[0..j-1]
( (( A ( A( A * ( * A( A * ( ( * ( A( A * ( B ( * ( A B( A * ( B * ( * ( * A B( A * ( B * C ( * ( * A B C( A * ( B * C + ( * ( + A B C *( A * ( B * C + D ( * ( + A B C * D( A * ( B * C + D ) ( * A B C * D +( A * ( B * C + D ) ) A B C * D + *
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 77 / 162
![Page 78: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/78.jpg)
Pilhas Implementação em lista encadeada
Pilha implementada em lista encadeada
typedef struct cel {int valor;struct cel *seg;
} célula;
Decisões de projeto
I lista com cabeça
I segunda célula: topo da pilha
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 78 / 162
![Page 79: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/79.jpg)
Pilhas Implementação em lista encadeada
Pilha vaziacélula cabeça;célula *p;p = &cabeça; /* p->seg é o topo da pilha */p->seg = NULL;
Inserevoid Empilha (int y, célula *p) {
célula *nova;nova = malloc (sizeof (célula));nova->valor = y;nova->seg = p->seg;p->seg = nova;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 79 / 162
![Page 80: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/80.jpg)
Pilhas Implementação em lista encadeada
Removeint Desempilha (célula *p) {
int x; célula *q;q = p->seg;x = q->valor;p->seg = q->seg;free (q);return x;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 80 / 162
![Page 81: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/81.jpg)
Busca em vetor ordenado
Problema:Encontrar um dado número x
num vetor crescente v[0 . . n−1].
Vetor é crescente se v[0] ≤ v[1] ≤ · · · ≤ v[n−1].
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 81 / 162
![Page 82: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/82.jpg)
Busca em vetor ordenado O problema
Problema mais geral
Dado x e um vetor crescente v[0 . . n−1],encontrar j tal que v[j−1] < x ≤ v[j].
I 0 ≤ j ≤ n
I se j = 0 então x ≤ v[0]I se j = n então v[n−1] < x
I imagine v[−1] = −∞ e v[n] =∞
0 12
111 222 333 444 555 555 666 777 888 888 888 999 999
Se x = 555 então j = 4. Se x = 1000 então j = 13. Se x = 110 então j = 0.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 82 / 162
![Page 83: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/83.jpg)
Busca em vetor ordenado Busca seqüencial
Algoritmo de busca seqüencialRecebe um vetor crescente v[0 . . n−1] com n ≥ 1 e um inteiro x.Devolve um índice j em 0 . . n tal que v[j−1] < x ≤ v[j].
int BuscaSeqüencial (int x, int n, int v[]) {int j = 0;while (j < n && v[j] < x) ++j;return j;
}
I invariante: no começo de cada iteração tem-se v[j−1] < x
I consumo de tempo: proporcional a n
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 83 / 162
![Page 84: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/84.jpg)
Busca em vetor ordenado Busca binária
Algoritmo de busca bináriaRecebe um vetor crescente v[0 . . n−1] com n ≥ 1 e um inteiro x.Devolve um índice j em 0 . . n tal que v[j−1] < x ≤ v[j].
int BuscaBinária (int x, int n, int v[]) {int e, m, d;e = -1; d = n;while (/*X*/ e < d - 1) {
m = (e + d)/2;if (v[m] < x) e = m;else d = m;
}return d;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 84 / 162
![Page 85: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/85.jpg)
Busca em vetor ordenado Busca binária
Invariante: a cada passagem pelo ponto X temos v[e] < x ≤ v[d].
0 e d n−1
111 222 333 444 555 555 666 777 888 888 888 999 999
Consumo de tempo
I em cada iteração, o tamanho do vetor em jogo é d− e− 1I tamanho do vetor na primeira, segunda, terceira, etc. iterações:
n, n/2, n/4, . . . , n/2k, . . .I número total de iterações: ∼= log2 n
I consumo de tempo: proporcional a log2 n
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 85 / 162
![Page 86: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/86.jpg)
Busca em vetor ordenado Busca binária
Versão recursivaint BuscaBinária2 (int x, int n, int v[]) {
return BuscaBinR (x, -1, n, v);}
BuscaBinR recebe um vetor crescente v[e . . d] e um x tal que v[e] < x ≤ v[d].Devolve um índice j no intervalo e+1 . . d tal que v[j−1] < x ≤ v[j].
int BuscaBinR (int x, int e, int d, int v[]) {if (e == d-1) return d;else {
int m = (e + d)/2;if (v[m] < x)
return BuscaBinR (x, m, d, v);else
return BuscaBinR (x, e, m, v);}
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 86 / 162
![Page 87: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/87.jpg)
ALGORITMOSDE ORDENAÇÃO
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 87 / 162
![Page 88: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/88.jpg)
Ordenação O problema
ProblemaRearranjar os elementos de um vetor v[0 . . n−1]de tal modo que ele fique crescente.
Vetor é crescente se v[0] ≤ v[1] ≤ · · · ≤ v[n−1].
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 88 / 162
![Page 89: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/89.jpg)
Ordenação
Ordenaçãopor inserçãopor seleção
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 89 / 162
![Page 90: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/90.jpg)
Ordenação Inserção
Algoritmo de ordenação por inserçãoRearranja o vetor v[0 . . n−1] em ordem crescente.
void Inserção (int n, int v[]) {int i, j, x;for (j = 1; /*A*/ j < n; j++) {
x = v[j];for (i = j-1; i >= 0 && v[i] > x; i--)
v[i+1] = v[i];v[i+1] = x;
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 90 / 162
![Page 91: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/91.jpg)
Ordenação Inserção
Invariantes: a cada passagem pelo ponto A
1. v[0 . . n−1] é uma permutação do vetor original2. o vetor v[0 . . j−1] é crescente
0 crescente j−1 j n−1
444 555 555 666 777 222 999 222 999 222 999
Consumo de tempo
I proporcional ao número de execuções de “v[i] > x”
I no pior caso, esse número é∑n−1
j=1 j = n (n− 1)/2
I consumo de tempo total: no máximo n2 unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 91 / 162
![Page 92: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/92.jpg)
Ordenação Seleção
Algoritmo de seleçãoRearranja o vetor v[0 . . n−1] em ordem crescente.
void Seleção (int n, int v[]) {int i, j, min, x;for (i = 0; /*A*/ i < n-1; i++) {
min = i;for (j = i+1; j < n; j++)
if (v[j] < v[min]) min = j;x = v[i]; v[i] = v[min]; v[min] = x;
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 92 / 162
![Page 93: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/93.jpg)
Ordenação Seleção
Invariantes: a cada passagem pelo ponto A
1. v[0 . . n−1] é uma permutação do vetor original2. v[0 . . i−1] está em ordem crescente3. v[i− 1] ≤ v[j] para j = i, i+1, . . . , n−1
0 i−1 i n−1
110 120 120 130 140 666 999 666 999 666 999
pequenos, crescente grandes
Consumo de tempo
I no máximo n2 unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 93 / 162
![Page 94: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/94.jpg)
Algoritmo Mergesort
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 94 / 162
![Page 95: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/95.jpg)
Mergesort Problema auxiliar
Problema principal
Rearranjar os elementos de um vetor v[0 . . n−1]de tal modo que ele fique crescente,ou seja, de modo que v[0] ≤ v[1] ≤ · · · ≤ v[n−1].
Problema auxiliar: intercalaçãoRearranjar v[p . . r−1] em ordem crescentesabendo que v[p . . q−1] e v[q . . r−1] são crescentes.
p q−1 q r−1
111 333 555 555 777 999 999 222 444 777 888
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 95 / 162
![Page 96: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/96.jpg)
Mergesort Intercalação de vetores ordenados
Algoritmo de intercalaçãoRecebe vetores crescentes v[p . . q−1] e v[q . . r−1]e rearranja v[p . . r−1] em ordem crescente.
void Intercala (int p, int q, int r, int v[]) {int i, j, k, *w;w = malloc ((r-p) * sizeof (int));i = p; j = q; k = 0;while (i < q && j < r) {
if (v[i] <= v[j]) w[k++] = v[i++];else w[k++] = v[j++];
}while (i < q) w[k++] = v[i++];while (j < r) w[k++] = v[j++];for (i = p; i < r; i++) v[i] = w[i-p];free (w);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 96 / 162
![Page 97: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/97.jpg)
Mergesort Intercalação de vetores ordenados
Consumo de tempo do algoritmo Intercala
I proporcional ao número de elementos do vetor
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 97 / 162
![Page 98: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/98.jpg)
Mergesort Algoritmo principal
Algoritmo Mergesort (ordena por intercalação)Rearranja o vetor v[p . . r−1] em ordem crescente.
void Mergesort (int p, int r, int v[]) {if (p < r - 1) {
int q = (p + r)/2;Mergesort (p, q, v);Mergesort (q, r, v);Intercala (p, q, r, v);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 98 / 162
![Page 99: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/99.jpg)
Mergesort Algoritmo principal
0 1 2 3 4 5 6 7 8 9 10
999 111 222 999 888 333 444 777 555 666 555
999 111 222 999 888 333 444 777 555 666 555
999 111 222 999 888 333 444 777 555 666 555
...
111 999 222 888 999 333 444 777 555 555 666
111 222 888 999 999 333 444 555 555 666 777
111 222 333 444 555 555 666 777 888 999 999
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 99 / 162
![Page 100: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/100.jpg)
Mergesort Algoritmo principal
v[0 . . n−1]v[0 . . n
2−1] v[n2 . . n−1]
v[0 . . n4−1] v[n
4 . . n2−1] v[n
2 . . 3n4 −1] v[3n
4 . . n−1]...
Consumo de tempo do Mergesort
I aproximadamente log2 n “rodadas”I cada “rodada” consome n unidades de tempoI total: n log2 n unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 100 / 162
![Page 101: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/101.jpg)
Mergesort Algoritmo principal
Versão iterativavoid MergesortI (int n, int v[]) {
int p, r, b = 1;while (b < n) {
p = 0;while (p + b < n) {
r = p + 2*b;if (r > n) r = n;Intercala (p, p + b, r, v);p = p + 2*b;
}b = 2*b;
}}
0 p p+b p+2b n−1
111 999 222 999 333 888 444 777 555 666 555
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 101 / 162
![Page 102: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/102.jpg)
Algoritmo Heapsort
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 102 / 162
![Page 103: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/103.jpg)
Heapsort Heap
ProblemaRearranjar os elementos de um vetor v[0 . . n−1]em ordem crescente.
DefiniçãoUm max-heap é um vetor v[1 . .m] tal que v[
⌊12f⌋] ≥ v[f ]
para f = 2, 3, . . . ,m.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
999 888 666 333 777 555 555 333 222 111 444 111 222 444 111
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 103 / 162
![Page 104: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/104.jpg)
Heapsort Heap
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 104 / 162
![Page 105: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/105.jpg)
Heapsort Algoritmo auxiliar 1
Algoritmo auxiliar 1: inserção em um heapTransforma v[1 . .m+1] em max-heap supondo que v[1 . .m] é max-heap.
void InsereEmHeap (int m, int v[]) {int f = m+1;while /*X*/ (f > 1 && v[f/2] < v[f]) {
int t = v[f/2]; v[f/2] = v[f]; v[f] = t;f = f/2;
}}
I invariante no pto X: v[⌊
12 i⌋] ≥ v[i] para i = 2, . . . ,m+1, i 6= f
I consumo: log2(m + 1) unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 105 / 162
![Page 106: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/106.jpg)
Heapsort Algoritmo auxiliar 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14
98 97 96 95 94 93 92 91 90 89 87 86 85 99
98 97 96 95 94 93 99 91 90 89 87 86 85 92
98 97 99 95 94 93 96 91 90 89 87 86 85 92
99 97 98 95 94 93 96 91 90 89 87 86 85 92
Transforma v[1 . . 14] em max-heapsupondo que v[1 . . 13] é max-heap.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 106 / 162
![Page 107: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/107.jpg)
Heapsort Algoritmo auxiliar 2
Algoritmo auxiliar 2Transforma quase-max-heap v[1 . .m] em max-heap.
void SacodeHeap (int m, int v[]) {int t, f = 2;while /*X*/ (f <= m) {
if (f < m && v[f] < v[f+1]) ++f;if (v[f/2] >= v[f]) break;t = v[f/2]; v[f/2] = v[f]; v[f] = t;f *= 2;
}}
I v[1 . .m] é quase-max-heap se v[⌊
12f⌋] ≥ v[f ] para f = 4, 5, . . . ,m
I invariante no ponto X: v[⌊
12 i⌋] ≥ v[i] quando i 6= f e i 6= f+1
I consumo: log2 m unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 107 / 162
![Page 108: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/108.jpg)
Heapsort Algoritmo principal
Algoritmo HeapsortRearranja vetor v[1 . . n] de modo que ele fique crescente.
void Heapsort (int n, int v[]) {int m;for (m = 1; m < n; m++)
InsereEmHeap (m, v);for (m = n; /*X*/ m > 1; m--) {
int t = v[1]; v[1] = v[m]; v[m] = t;SacodeHeap (m-1, v);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 108 / 162
![Page 109: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/109.jpg)
Heapsort Algoritmo principal
Invariantes no ponto X
I v[1 . .m] é um max-heap
I v[1 . .m] ≤ v[m+1 . . n]
I v[m+1 . . n] está em ordem crescente
1 max-heap m crescente n
777 777 666 444 222 111 444 333 777 888 888 999 999
elementos pequenos elementos grandes
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 109 / 162
![Page 110: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/110.jpg)
Heapsort Algoritmo principal
Consumo de tempo do Heapsort
I no pior caso: n log2 n unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 110 / 162
![Page 111: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/111.jpg)
Algoritmo Quicksort
Problema:Rearranjar um vetor v[0 . . n−1]
em ordem crescente.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 111 / 162
![Page 112: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/112.jpg)
Quicksort Subproblema da separação
Subproblema da separação: formulação vagaRearranjar um vetor v[p . . r] de modo queos elementos pequenos fiquem todos do lado esquerdoe os grandes do lado direito.
Formulação concretaRearranjar v[p . . r] de modo que v[p . . j−1] ≤ v[j] < v[j+1 . . r]para algum j em p . . r.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 112 / 162
![Page 113: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/113.jpg)
Quicksort Subproblema da separação
Algoritmo da separaçãoRecebe um vetor v[p . . r] com p ≤ r.Rearranja os elementos do vetor edevolve j em p . . r tal que v[p . . j−1] ≤ v[j] < v[j+1 . . r].
int Separa (int p, int r, int v[]) {int c, j, k, t;c = v[r]; j = p;for (k = p; /*A*/ k < r; k++)
if (v[k] <= c) {t = v[j], v[j] = v[k], v[k] = t;j++;
}v[r] = v[j], v[j] = c;return j;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 113 / 162
![Page 114: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/114.jpg)
Quicksort Subproblema da separação
Invariantes no ponto A
I v[p . . r] é uma permutação do vetor original
I v[p . . j−1] ≤ c < v[j . . k−1] e v[r] = c
I p ≤ j ≤ k ≤ r
p j k r
≤ c ≤ c ≤ c > c > c > c ? ? ? = c
j k
≤ c ≤ c ≤ c ≤ c > c > c > c > c > c = c
j
≤ c ≤ c ≤ c ≤ c = c > c > c > c > c > c
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 114 / 162
![Page 115: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/115.jpg)
Quicksort Subproblema da separação
j k
≤ c ≤ c ≤ c ≤ c > c > c > c > c > c = c
última passagem pelo ponto A
j
≤ c ≤ c ≤ c ≤ c = c > c > c > c > c > c
resultado final
Consumo de tempo do algoritmo Separa
proporcional ao número de elementos do vetor
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 115 / 162
![Page 116: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/116.jpg)
Quicksort Algoritmo principal
Algoritmo QuicksortRearranja o vetor v[p . . r], com p ≤ r + 1,de modo que ele fique em ordem crescente.
void Quicksort (int p, int r, int v[]) {int j;if (p < r) {
j = Separa (p, r, v);Quicksort (p, j - 1, v);Quicksort (j + 1, r, v);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 116 / 162
![Page 117: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/117.jpg)
Quicksort Algoritmo principal
Consumo de tempo do Quicksort
I no pior caso: n2 unidades de tempoI em média: n log2 n unidades de tempo
n := r − p + 1
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 117 / 162
![Page 118: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/118.jpg)
Quicksort Altura da pilha de execução
Quicksort com controle da altura da pilha de execuçãoCuida primeiro do menor dos subvetores v[p . . j−1] e v[j+1 . . r].
void QuickSortP (int p, int r, int v[]) {int j;while (p < r) {
j = Separa (p, r, v);if (j - p < r - j) {
QuickSortP (p, j - 1, v);p = j + 1;
} else {QuickSortP (j + 1, r, v);r = j - 1;
}}
}
Altura da pilha de execução: log2 n
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 118 / 162
![Page 119: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/119.jpg)
Algoritmosde enumeração
Enumerar = fazer uma listade todos os objetos de um determinado tipo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 119 / 162
![Page 120: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/120.jpg)
Algoritmos de enumeração Enumeração de subseqüências
ProblemaFazer uma lista, sem repetições, de todas as subseqüências de 1, 2, . . . , n.
11 21 2 31 2 3 41 2 41 31 3 41 422 32 3 42 433 44
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 120 / 162
![Page 121: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/121.jpg)
Algoritmos de enumeração Ordem lexicográfica
Ordem lexicográfica de seqüências〈r1, r2, . . . , rj〉 precede 〈s1, s2, . . . , sk〉 se1. j < k e 〈r1, . . . , rj〉 = 〈s1, . . . , sj〉 ou2. existe i tal que 〈r1, . . . , ri−1〉 = 〈s1, . . . , si−1〉 e ri < si
Algoritmo de enumeração em ordem lexicográficaRecebe n ≥ 1 e imprime todas as subseqüências não-vazias de 1, 2, . . . , nem ordem lexicográfica.
void SubseqLex (int n) {int *s, k;s = malloc ((n+1) * sizeof (int));processo iterativofree (s);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 121 / 162
![Page 122: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/122.jpg)
Algoritmos de enumeração Ordem lexicográfica
processo iterativo
s[0] = 0; k = 0;while (1) {
if (s[k] < n) {s[k+1] = s[k] + 1;k += 1;
} else {s[k-1] += 1;k -= 1;
}if (k == 0) break;imprima (s, k);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 122 / 162
![Page 123: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/123.jpg)
Algoritmos de enumeração Ordem lexicográfica
InvarianteCada iteração começa com subseqüência 〈s1, s2, . . . , sk〉 de 〈1, 2, . . . , n〉.
k0 1 2 3 4 5 6 7
0 2 4 5 7 8 ? ?
Vetor s no início de uma iteraçãode SubseqLex com n = 7.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 123 / 162
![Page 124: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/124.jpg)
Algoritmos de enumeração Ordem lexicográfica
Versão recursivavoid SubseqLex2 (int n) {
int *s;s = malloc ((n+1) * sizeof (int));SseqR (s, 0, 1, n);free (s);
}
void SseqR (int s[], int k, int m, int n) {if (m <= n) {
s[k+1] = m;imprima (s, k+1);SseqR (s, k+1, m+1, n); /* inclui m */SseqR (s, k, m+1, n); /* não inclui m */
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 124 / 162
![Page 125: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/125.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
Ordem lexicográfica especial〈r1, r2, . . . , rj〉 precede 〈s1, s2, . . . , sk〉 se1. j > k e 〈r1, . . . , rk〉 = 〈s1, . . . , sk〉 ou2. existe i tal que 〈r1, . . . , ri−1〉 = 〈s1, . . . , si−1〉 e ri < si
1 2 3 41 2 31 2 41 21 3 41 31 412 3 42 32 423 434
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 125 / 162
![Page 126: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/126.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
Algoritmo de enumeração em ordem lexicográfica especialRecebe n ≥ 1 e imprime, em ordem lexicográfica especial,todas as subseqüências não-vazias de 1, 2, . . . , n.
void SubseqLexEsp (int n) {int *s, k;s = malloc ((n+1) * sizeof (int));processo iterativo
free (s);}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 126 / 162
![Page 127: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/127.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
processo iterativo
s[1] = 0; k = 1;while (1) {
if (s[k] == n) {k -= 1;if (k == 0) break;
} else {s[k] += 1;while (s[k] < n) {
s[k+1] = s[k] + 1;k += 1;
}}imprima (s, k);
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 127 / 162
![Page 128: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/128.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
Versão recursivaRecebe n ≥ 1 e imprime todas as subseqüências de 1, 2, . . . , nem ordem lexicográfica especial.
void SubseqLexEsp2 (int n) {int *s;s = malloc ((n+1) * sizeof (int));SseqEspR (s, 0, 1, n);free (s);
}
continua. . .
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 128 / 162
![Page 129: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/129.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
continuaçãoRecebe um vetor s[1 . . k] e imprime, em ordem lexicográfica especial,todas as seqüências da forma s[1], . . . , s[k], t[k+1], . . .tais que t[k+1], . . . é uma subseqüência de m, m+1, . . . , n.Em seguida, imprime a seqüência s[1], . . . , s[k].
void SseqEspR (int s[], int k, int m, int n) {if (m > n) imprima (s, k);else {
s[k+1] = m;SseqEspR (s, k+1, m+1, n); /* inclui m */SseqEspR (s, k, m+1, n); /* não inclui m */
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 129 / 162
![Page 130: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/130.jpg)
Algoritmos de enumeração Ordem lexicográfica especial
2 4 7 8 92 4 7 82 4 7 92 4 72 4 8 92 4 82 4 92 4 92 4
Resultado de SseqEspR (s,2,7,9)
supondo s[1] = 2 e s[2] = 4.
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 130 / 162
![Page 131: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/131.jpg)
Busca de palavrasem um texto
Problema:Encontrar as ocorrências de a[1 . .m] em b[1 . . n].
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 131 / 162
![Page 132: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/132.jpg)
Busca de palavras Exemplos
a l g o r í t i m o
O s a l g o r í t i m o s d e o r d e n a ç ã o↑
3 1 4 1 5 9
3 1 3 1 4 3 1 4 1 3 1 4 1 5 9 3 1 4 1 5 9 2 6 3 1 4↑ ↑
T A C T A
G T A G T A T A T A T A T A T A C T A C T A G T A G↑ ↑
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 132 / 162
![Page 133: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/133.jpg)
Busca de palavras O problema
Definições
I a[1 . .m] é sufixo de b[1 . . k] sem ≤ k e a[1 . .m] = b[k−m+1 . . k]
I a[1 . .m] ocorre em b[1 . . n] seexiste k no intervalo m . . n tal que a[1 . .m] é sufixo de b[1 . . k]
ProblemaEncontrar o número de ocorrências de a[1 . .m] em b[1 . . n].
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 133 / 162
![Page 134: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/134.jpg)
Busca de palavras O problema
typedef unsigned char *palavra;typedef unsigned char *texto;
Algoritmo trivialRecebe palavra a[1 . .m] e texto b[1 . . n], com m ≥ 1 e n ≥ 0,e devolve o número de ocorrências de a em b.
int trivial (palavra a, int m, texto b, int n) {int k, r, ocorrs;ocorrs = 0;for (k = m; k <= n; k++) {
r = 0;while (r < m && a[m-r] == b[k-r]) r += 1;if (r >= m) ocorrs += 1;
}return ocorrs;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 134 / 162
![Page 135: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/135.jpg)
Busca de palavras Primeiro algoritmo de Boyer–Moore
Algoritmo de Boyer–Moore
B C B A
X C B A B X C B A A X B C B A B Xˆ ˆ ˆ ˆ ˆ ˆ
posições k em que a[1 . . 4] é comparada com b[k−3 . . k]
1 2 3 4B C B A
c · · · ? @ A B C D E F G · · ·T1[c] · · · 4 4 0 1 2 4 4 4 4 · · ·
Tabela de deslocamentos T1
T1[c] é o menor t em 0 . .m−1 tal que a[m− t] = c
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 135 / 162
![Page 136: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/136.jpg)
Busca de palavras Primeiro algoritmo de Boyer–Moore
Primeiro algoritmo de Boyer–MooreRecebe uma palavra a[1 . .m] e um texto b[1 . . n], com m ≥ 1 e n ≥ 0,e devolve o número de ocorrências de a em b.Supõe que cada elemento de a e b pertence ao conjunto de caracteres 0..255.
int BoyerMoore1 (palavra a, int m, texto b, int n) {int T1[256], i, k, r, ocorrs;/* pré-processamento da palavra a */for (i = 0; i < 256; i++) T1[i] = m;for (i = 1; i <= m; i++) T1[a[i]] = m - i;busca da palavra a no texto b
return ocorrs;}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 136 / 162
![Page 137: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/137.jpg)
Busca de palavras Primeiro algoritmo de Boyer–Moore
busca da palavra a no texto b
ocorrs = 0; k = m;while (k <= n) {
r = 0;while (m - r >= 1 && a[m-r] == b[k-r]) r += 1;if (m - r < 1) ocorrs += 1;if (k == n) k += 1;else k += T1[b[k+1]] + 1;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 137 / 162
![Page 138: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/138.jpg)
Busca de palavras Segundo algoritmo de Boyer–Moore
Segundo algoritmo de Boyer–MooreTabela de deslocamentos T2
T2[i] é o menor t em 1 . .m−1 tal que m− t é bom para i
j é bom para i se a[i . . m] é sufixo de a[1 . . j]ou a[1 . . j] é sufixo de a[i . . m]
1 2 3 4 5 6C A A B A A
i 6 5 4 3 2 1T2[i] 1 3 6 6 6 6
1 2 3 4 5 6 7 8B A - B A . B A
i 8 7 6 5 4 3 2 1T2[i] 3 3 6 6 6 6 6 6
1 2 3 4 5 6 7 8 9 10 11B A - B A * B A * B A
i 11 10 9 8 7 6 5 4 3 2 1T2[i] 3 3 3 3 3 9 9 9 9 9 9
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 138 / 162
![Page 139: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/139.jpg)
Busca de palavras Segundo algoritmo de Boyer–Moore
Segundo algoritmo de Boyer–MooreRecebe uma palavra a[1 . .m] com 1 ≤ m ≤ MAX e um texto b[1 . . n]e devolve o número de ocorrências de a em b.
int BoyerMoore2 (palavra a, int m, texto b, int n) {int T2[MAX], i, j, k, r, ocorrs;/* pré-processamento da palavra a */for (i = m; i >= 1; i--) {
j = m-1; r = 0;while (m - r >= i && j - r >= 1)
if (a[m-r] == a[j-r]) r += 1;else j -= 1, r = 0;
T2[i] = m - j;}
busca da palavra a no texto b
return ocorrs;}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 139 / 162
![Page 140: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/140.jpg)
Busca de palavras Segundo algoritmo de Boyer–Moore
busca da palavra a no texto b
ocorrs = 0; k = m;while (k <= n) {
r = 0;while (m - r >= 1 && a[m-r] == b[k-r]) r += 1;if (m - r < 1) ocorrs += 1;if (r == 0) k += 1;else k += T2[m-r+1];
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 140 / 162
![Page 141: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/141.jpg)
Busca de palavras Segundo algoritmo de Boyer–Moore
Consumo de tempo dos algoritmos de Boyer–Moore
I pré-processamento: m2 unidades de tempoI busca, pior caso: mn unidades de tempoI busca, em média: n unidades de tempo
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 141 / 162
![Page 142: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/142.jpg)
Árvores binárias
ss s
s s s ss s s
����
@@@@R
�
JJJ
�
JJJ
���AAU
AAU
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 142 / 162
![Page 143: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/143.jpg)
Árvores binárias Definição
Estrutura de um nóstruct cel {
int conteúdo;struct cel *esq;struct cel *dir;
};
typedef struct cel nó;
999
conteúdo
esq dirr����
rAAAU
typedef nó *árvore;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 143 / 162
![Page 144: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/144.jpg)
Árvores binárias Varredura esquerda-raiz-direita
Varredura esquerda-raiz-direita
Visite
I a subárvore esquerda (em ordem e-r-d)I depois a raizI depois a subárvore direita (em ordem e-r-d)
s5
s3 s8
s1 s4 s6 s9s0 s2 s7
��
��
@@@@R
�
JJJ
�
JJJ
���AAU
AAU
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 144 / 162
![Page 145: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/145.jpg)
Árvores binárias Varredura esquerda-raiz-direita
Algoritmo de varredura e-r-dRecebe uma árvore binária re imprime o conteúdo de seus nós em ordem e-r-d.
void Erd (árvore r) {if (r != NULL) {
Erd (r->esq);printf ("%d\n", r->conteúdo);Erd (r->dir);
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 145 / 162
![Page 146: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/146.jpg)
Árvores binárias Varredura esquerda-raiz-direita
Versão iterativavoid ErdI (árvore r) {
nó *p[100], *x;int t = 0;x = r;while (x != NULL || t > 0) {
/* o topo da pilha p[0..t-1] está em t-1 */if (x != NULL) {
p[t++] = x;x = x->esq;
}else {
x = p[--t];printf ("%d\n", x->conteúdo);x = x->dir;
}}
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 146 / 162
![Page 147: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/147.jpg)
Árvores binárias Altura
Altura
I de nó = distância entre nó e seu descendente mais afastadoI de árvore = altura da raiz
Se árvore tem n nós e altura h então blog2 nc ≤ h < n.
ss s
s s s ss s s s s
����
@@@@R
�
JJJ
�
JJJ
���AAU
���AAU
���
h = blog2 12c = 3
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 147 / 162
![Page 148: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/148.jpg)
Árvores binárias Altura
Algoritmo da alturaDevolve a altura da árvore binária r.
int Altura (árvore r) {if (r == NULL)
return -1; /* a altura de uma árvore vazia é -1 */else {
int he = Altura (r->esq);int hd = Altura (r->dir);if (he < hd) return hd + 1;else return he + 1;
}}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 148 / 162
![Page 149: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/149.jpg)
Árvores binárias Nó seguinte
Estrutura de nó com campo pai
struct cel {int conteúdo;struct cel *pai;struct cel *esq;struct cel *dir;
};
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 149 / 162
![Page 150: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/150.jpg)
Árvores binárias Nó seguinte
Algoritmo do nó seguinteRecebe um nó x de uma árvore binária cujos nós têm campo paie devolve o (endereço do) nó seguinte na ordem e-r-d.A função supõe que x 6= NULL.
nó *Seguinte (nó *x) {if (x->dir != NULL) {
nó *y = x->dir;while (y->esq != NULL) y = y->esq;return y;
}while (x->pai != NULL && x->pai->dir == x)
x = x->pai;return x->pai;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 150 / 162
![Page 151: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/151.jpg)
Árvores bináriasde busca
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 151 / 162
![Page 152: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/152.jpg)
Árvores de busca Definição
Estrutura de um nóstruct cel {
int chave;int conteúdo;struct cel *esq;struct cel *dir;
};typedef struct cel nó;
Árvore de busca: definição
E.chave ≤ X.chave ≤ D.chave
para todo nó X, todo nó E na subárvore esquerda de Xe todo nó D na subárvore direita de X
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 152 / 162
![Page 153: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/153.jpg)
Árvores de busca Busca
Algoritmo de buscaRecebe k e uma árvore de busca r.Devolve um nó cuja chave é k ou devolve NULL se tal nó não existe.
nó *Busca (árvore r, int k) {if (r == NULL || r->chave == k)
return r;if (r->chave > k)
return Busca (r->esq, k);else
return Busca (r->dir, k);}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 153 / 162
![Page 154: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/154.jpg)
Árvores de busca Busca
Versão iterativawhile (r != NULL && r->chave != k) {
if (r->chave > k) r = r->esq;else r = r->dir;
}return r;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 154 / 162
![Page 155: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/155.jpg)
Árvores de busca Inserção
nó *novo;novo = malloc (sizeof (nó));novo->chave = k;novo->esq = novo->dir = NULL;
Algoritmo de inserçãoRecebe uma árvore de busca r e uma folha avulsa novo.Insere novo na árvore de modo que a árvore continue sendo de buscae devolve o endereço da nova árvore.
árvore Insere (árvore r, nó *novo) {nó *f, *p;if (r == NULL) return novo;processo iterativo
return r;}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 155 / 162
![Page 156: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/156.jpg)
Árvores de busca Inserção
processo iterativo
f = r;while (f != NULL) {
p = f;if (f->chave > novo->chave) f = f->esq;else f = f->dir;
}if (p->chave > novo->chave) p->esq = novo;else p->dir = novo;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 156 / 162
![Page 157: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/157.jpg)
Árvores de busca Remoção
Algoritmo de remoção da raizRecebe uma árvore não-vazia r, remove a raiz da árvore erearranja a árvore de modo que ela continue sendo de busca.Devolve o endereço da nova raiz.
árvore RemoveRaiz (árvore r) {nó *p, *q;if (r->esq == NULL) q = r->dir;else {
processo iterativo}free (r);return q;
}
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 157 / 162
![Page 158: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/158.jpg)
Árvores de busca Remoção
processo iterativo
p = r; q = r->esq;while (q->dir != NULL) {
p = q; q = q->dir;}/* q é o nó anterior a r na ordem e-r-d *//* p é o pai de q */if (p != r) {
p->dir = q->esq;q->esq = r->esq;
}q->dir = r->dir;
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 158 / 162
![Page 159: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/159.jpg)
Árvores de busca Remoção
Exemplo: antes e depois de RemoveRaiz
ss ss ss sss sss s
r
112 12
1 4
3 p6
5 q10
f8
7 9
��@@R
��@@R��@@R��@@R��
��@@R
ss ss ss sss ss s
q
102 12
1 4
3 p6
5 f8
7 9
��@@R
��@@R��@@R��@@R��@@R
nó f passa a ser o filho direito de pnó q fica no lugar de r
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 159 / 162
![Page 160: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/160.jpg)
Árvores de busca Remoção
Remoção do filho esquerdo de x
x->esq = RemoveRaiz (x->esq);
Remoção do filho direito de x
x->dir = RemoveRaiz (x->dir);
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 160 / 162
![Page 161: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/161.jpg)
Árvores de busca Desempenho dos algoritmos
Consumo de tempo da busca, inserção e remoção
I pior caso: proporcional à altura da árvoreI árvore “balanceada”: proporcional a log2 n
n = número de nós da árvore
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 161 / 162
![Page 162: ALGORITMOS em linguagem C - IME-USPpf/algoritmos-livro/slides/... · 2013. 4. 30. · “Ciênciadacomputaçãonãoéaciênciadoscomputadores, assimcomoaastronomianãoéaciênciadostelescópios.”](https://reader033.vdocuments.mx/reader033/viewer/2022051409/601a74340978ed179d12118d/html5/thumbnails/162.jpg)
Fim
P. Feofiloff (IME-USP) Algoritmos em C Campus/Elsevier 162 / 162