# Análise de algoritmos para a solução do Problema da Seleção
> Por Guilherme de Abreu Barreto[^1]
## Resumo
É o objetivo deste relatório definir o *Problema da Seleção* e apresentar dois algoritmos passíveis de solucioná-lo. Compara-se as estratégias adotadas em cada algoritmo, assim como o tempo de execução previsto e experimental de cada qual. Com base nessas observações infere-se a eficiência relativa dos algoritmos.
## Introdução
O *Problema da Seleção* no contexto desta análise refere-se a necessidade de, para uma sequência de elementos $x_a, \dots, x_i, \dots, x_b$ onde $a \le i \le b$, sendo $a$ e $b$ sendo os índices inicial e final respectivamente, acessar o $i$-esimo elemento $x_i$ de acordo com um dado parâmetro. Iremos aqui admitir que $\forall x \in \Z$ e utilizaremos como critério o valor de $x$ de maneira a selecionar o $i$-esimo elemento de menor valor. Vamos abordar este problema de duas formas:
Na primeira solução (solução `mergeSelect`) ordenaremos o conjunto de elementos em ordem crescente para, em seguida, acessar $a_i$ diretamente.
Na segunda solução (solução `quickSelect`) continuamente particionaremos a sequência à partir de comparações com o valor de um elemento desta, o pivô. Isso até que, ou o pivô ao final do processo de partição corresponda ao índice $i$, ou o conjunto particionado avaliado tenha tamanho 1 (portanto, contendo somente o elemento de índice $i$).
### Solução *mergeSelect*
#### Definição
O algoritmo aqui implementado para a ordenação do arranjo de valores inteiros é o *Merge Sort*, que dá nome a solução. Trata-se de um algoritmo de ordenação eficiente e estável pautado pela comparação de valores e baseado no paradigma da *Divisão e Conquista*.
Conceitualmente, seu funcionamento se dá da seguinte maneira:
1. Divide-se o arranjo em $n$ sub-arranjos de tamanho 1, sendo $n$ o tamanho do conjunto original a ser ordenado, pois uma lista de um único elemento trivialmente já se encontra ordenada;
2. continuamente integra-se e ordena-se os sub-arranjos pré-ordenados para a par; até que
3. resta apenas a lista original ordenada. A partir de então, para encontrar o $i$-ésimo menor elemento, basta referenciar o arranjo pelo índice $i$: `A[i]`.
Podemos aferir que o algoritmo acima é correto (isto é, adequado a produzir a solução) pois
1. Nas linhas 19 e 20 subdivide-se a sequência em pares recursivamente, procedimento este que se repetirá até que restem apenas subconjuntos de 1 elemento e a função retorne na linha 17.
2. Cada recursão anterior então acessa a função `merge` na linha 21. Esta integrará pares de conjuntos adjacentes ao índice `pivot` nas linhas 7 e 8, percorrendo-os cada qual desde seus respectivos índices iniciais `i` e `j` e posicionando o elemento de menor valor no índice $k$. Isso, seguro de que estes já estarão ordenados em ordem crescente dada a condição anterior. Este então retornará os elementos de ambos os conjuntos em ordem crescente na linha 10.
3. O procedimento anterior se repete $(n - 1)$ vezes até que todos os pares ordenados combinados produzem a sequência original ordenada.
Assim, o algoritmo corresponde a definição dada anteriormente.
##### Teste empírico
A correção do algoritmo foi testada manualmente para pequenos arranjos utilizando o programa `manual_test.c`[^4].
#### Tempo de Execução
É possível afirmar que o tempo de execução $T(n)$ do *Merge Sort* para quaisquer entradas de mesmo tamanho $n$ é assintoticamente equivalente pois independentemente dos valores contidos na entrada, as mesmas operações de comparação (na linha 7) e atribuição (na linha 10) são executadas. Isto é, diferentemente do que é visto noutros algoritmos de ordenação tais quais o *Quick Sort* ou o *Insertion Sort*. Para estimar este tempo de execução, podemos recorrer ao *Teorema Mestre para recorrências de Divisão e Conquista*, por este ser um algoritmo do tipo *Divisão e Conquista*. Segundo Márcio Ribeiro (2021) o teorema mestre pode ser descrito nos seguintes termos:
> Sejam $a \ge 1$, $b > 1$ e $T (n) = aT \left( \frac nb \right) + f (n)$, então:
>
> 1. se $f(n) \in O\left(n^{\log_b (a − \varepsilon)} \right)$ para algum $\varepsilon > 0$ então $T (n) \in \Theta(n^{\log_ba} )$;
>
> 2. se $f(n) ∈ Θ(n^{log_ba})$ então $T(n) \in \Theta(n^{\log_ba} \cdot \text{lg}(n))$;
>
> 3. se $f(n) \in \Omega \left(n^{\log_b (a + \varepsilon)} \right)$ para algum $\varepsilon > 0$ e se $af \left(\frac nb \right) \le cf(n)$ para algum $c <1$etodo$n$suficientementegrandeentão$T(n) \inΘ(f(n))$
Temos que o tempo de execução $T(n)$ em função do tamanho $n$ da entrada do algoritmo *Merge Sort* é constante das linhas 14 à 18 mas varia nas linhas 19 e 20 ($T\left(\frac n2 \right)$ cada), e 21 ($cn$, para uma constante $c > 0$). Assim temos que a forma geral do tempo de execução é:
$$
T(n) = 2T\left(\frac n2 \right) + cn
$$
Ou seja, conforme a definição $aT \left( \frac nb \right) + f (n)$ tem-se que
- $a = b = 2$;
- $n^{\log_ba} = n^{log_22} = n$;
- $f(n) = cn$, sendo $\Theta(cn) \equiv \Theta(n)$;
- e portanto $f(n) \in \Theta(n^{\log_ba})$ pois $\Theta(n^{\log_ba}) = \Theta(n)$.
O algoritmo `quickSelect`, tal qual o algoritmo *Quick Sort*, foi desenvolvido por Tony Hoare e utiliza a mesma estratégia do último para comparar valores.
Conceitualmente, seu funcionamento se dá da seguinte maneira:
- Particiona-se a sequência à partir do valor de um elemento qualquer contido nessa, separando-a em dois subconjuntos contendo respectivamente
- valores maiores ou iguais;
- e menores que o pivô.
Portanto, o pivô passa a ocupar uma posição intermediária às partições;
- Se o pivô assume a posição do índice buscado ou resta apenas um único índice no conjunto particionado, a busca se encerra; senão repete-se o procedimento na partição aquela que contiver o índice $i$ (sendo este menor ou maior que o pivô).
#### Implementação
```c
1 │ #define array int*
2 │
3 │ void swap (int *a, int *b) {
4 │ int tmp = *a;
5 │ *a = *b;
6 │ *b = tmp;
7 │ }
8 │
9 │ int partition (array A, int pivot, int size) {
10 │ int i, j, lastIndex = size - 1;
11 │
12 │ swap(&A[pivot], &A[lastIndex]);
13 │ for (i = j = 0; i <lastIndex;i++)
14 │ if (A[i] <= A[lastIndex])
15 │ swap(&A[i], &A[j++]);
16 │ swap(&A[i], &A[j]);
17 │ return j;
18 │ }
19 │
20 │ int * quickSelect (array A, int size, int i) {
Podemos aferir que o algoritmo acima é correto pois
1. Se a a entrada contiver um único elemento, este é o elemento devolvido — Este é o caso base.
2. Senão, o conjunto é particionado na linha 24 e comparações são feitas nas linhas 25 para aferir se o índice foi encontrado no pivô ou, senão, na linha 27 determina-se em qual partição o procedimento de busca deve ser repetido até que as condições anteriores sejam satisfeitas.
3. Como toda partição é menor que o conjunto que lhe deu origem, no pior caso eventualmente a partição avaliada será pequena o suficiente para corresponder ao caso base.
##### Teste empírico
A correção do algoritmo anterior foi testada manualmente para pequenos arranjos utilizando o programa `manual_test.c`[^5].
#### Tempo de Execução
O tempo de execução deste algoritmo pode variar bastante em função do posicionamento do pivô ao final de cada procedimento de partição. Analisemos, portanto, aqueles que podem ser considerados o melhor, o pior, e o caso médio.
##### Análise do melhor caso
O melhor caso para a execução deste algoritmo é aquele em que o $i$-ésimo menor elemento do arranjo já se encontra na $i$-ésima posição ao iniciarmos a busca. Assim, a partição será feita com este elemento enquanto pivô na linha 13, retornando o mesmo a sua posição inicial na linha 16, e a busca estará findada tendo percorrido o arranjo uma única vez na linha 27. Desta forma, o tempo de busca em função do tamanho da entrada escalaria de forma estritamente linear. Ou seja, $T(n) \in \Theta(n)$.
##### Análise do pior caso
O pior caso para a execução deste algoritmo seria aquele onde o usuário busca o menor valor de um arranjo que encontra-se perfeitamente em ordem crescente **à partir do segundo elemento**. Assim, o primeiro elemento tem o maior valor e cada processo de partição se dá de forma em que o pivô é o $(n - (i - 1))$ maior elemento, produzindo assim partições de tamanho menor que a anterior em apenas uma unidade. Assim o arranjo é percorrido de maneira a realizar um número de $S_n$ de comparações na linha 14 equivalente à:
Ou seja, o tempo de execução do algoritmo restaria em ordem quadrática: $T(n) \in \Theta(n^2)$.
##### Análise do caso médio
Aplicando-se o Teorema Mestre conseguimos avaliar o **caso médio**, pois este admite que recursões são feitas em conjuntos menores de igual tamanho entre si. Fosse sempre este o caso com este algoritmo o índice $i$ ser menor ou maior que aquele do pivô não afetaria o tempo de execução da recursão seguinte, o qual também não seria nem muito pequeno (com o tamanho da partição seguinte abaixo da média) ou muito grande (com o tamanho da partição seguinte acima da média).
Temos que o tempo de execução $T(n)$ em função do tamanho $n$ da entrada do algoritmo *quickSelect* é constante nas linhas 20 à 23, 25 à 26 e 27 mas varia na linha 24 ($cn$, para uma constante $c > 0$) e nas linhas 28 e 29 ($T\left(\frac n2 \right)$ cada), das quais apenas uma delas é executada condicionalmente. Assim temos que a forma geral do tempo de execução é:
$$
T(n) = T\left(\frac n2 \right) + cn
$$
Ou seja, conforme a definição $aT \left( \frac nb \right) + f (n)$ tem-se que
- $a = 1$ e $b = 2$;
- $n^{\log_ba} = n^{log_21} = n^0 = 1$;
- $f(n) = cn$, sendo $\Theta(cn) \equiv \Theta(n)$;
- e portanto $f(n) \in \Omega \left( n^{\log_b(a+ \varepsilon)} \right)$ pois $\Omega \left(n^{\log_2(1 + 1)} \right) = \Omega(n)$.
Assim, temos pela aplicação do teorema que:
$$
T(n) \in \Theta(cn) \implies T(n) \in \Theta(n)
$$
Vemos então que teoricamente o caso médio aproxima-se mais da situação observada no melhor caso que do pior caso e, para valores de $n$ suficientemente grandes, oferece melhor desempenho com relação a solução `mergeSelect`.
## Objetivo
Iremos comparar o desempenho de ambas as soluções para uma mesma entrada de tamanho $n$, para valores de $n$ cada vez maiores. Para tal utilizaremos o seguinte equipamento:
OpenGL: renderer: Mesa Intel HD Graphics 5500 (BDW GT2)
v: 4.6 Mesa 21.2.3
Network:
Device-1: Realtek RTL810xE PCI Express Fast Ethernet driver: r8169
Device-2: Intel Wireless 7265 driver: iwlwifi
Device-3: Intel Bluetooth wireless interface type: USB
driver: btusb
Drives:
Local Storage: total: 931.51 GiB used: 916.26 GiB (98.4%)
Info:
Processes: 288 Uptime: 1h 59m Memory: 15.55 GiB
used: 3.66 GiB (23.6%) Shell: fish inxi: 3.3.08
```
Os valores a serem avaliados[^6] serão sorteados fazendo uso do programa `gerador`[^7] e o índice a ser buscado será sorteado fazendo uso uso do comando `random`, função do shell `fish` na versão `3.3.1`. Este é um exemplo do cabeçalho de um arquivo de texto gerado desta forma:
```shell
> head -4 tests/1.txt
10000 4430
1747153665
1888832918
1550537203
>
```
O primeiro valor (`10000`) descreve o tamanho da entrada, o segundo (`4430`) o índice buscado, os valores restantes são uma amostra daqueles a serem avaliados. tais aquivos serão providos enquanto argumentos para os programas de teste[^8][^9], e o desempenho destes será avaliado fazendo uso do comando `time`, também função do shell `fish`, da seguinte maneira:
```shell
> time mergeSelect/automatic_test.out <tests/1.txt
> Tamanho da entrada dado em dezena de milhares (10^4^) e tempo de execução em milissegundos (ms).
## Conclusão
A análise preliminar dos algoritmos de busca elaborou quantitativamente minha expectativa para crescimentos significativamente distintos do tempo de execução em função do tamanho da entrada, a qual foi seguidamente demonstrada em um experimento empírico. É possível afirmar que dentre os algoritmos apresentados o *quickSelect* é aquele mais eficiente na solução do problema apresentado dada uma entrada com valores aleatórios e com pouca ou nenhuma repetição, situação esta que corresponde de maneira mais próxima a seu caso médio. Podemos atribuir esta maior eficiência ao seu procedimento de particionamento que apenas parcialmente ordena o arranjo de valores, ainda que suficientemente para encontrar o $i$-ésimo maior valor, reduzindo desta forma o número de comparações feitas.
Por fim, fica demonstrada a importância e utilidade de métodos de análise de algoritmos para verificar a correção e desempenho destes à partir da avaliação de seu código, em particular na identificação de padrões de recorrência como a *Divisão e Conquista* e na aplicação do *Teorema Mestre* tal qual foi aqui realizado.
Abreu