Análise de algoritmos: Relatório trabalho prático 1

Eduardo Antunes Bueno

João Otávio Rocha Hernandes

Luisa Viana Rodrigues

Adamantina

2023
 Sumário

BUBBLE SORT (VERSÃO ORIGINAL SEM MELHORIAS) ............................................. 3

BUBBLE SORT MELHORADO (VERSÃO QUE VERIFICA SE O VETOR JÁ ESTÁ
ORDENADO) ................................................................................................................... 4
INSERTION SORT ........................................................................................................... 4
SHELL SORT ................................................................................................................... 6
SELECTION SORT .......................................................................................................... 7
QUICK SORT (COM PIVÔ SENDO O PRIMEIRO ELEMENTO DA LISTA –PARTIÇÃO)
......................................................................................................................................... 8
QUICK SORT (COM PIVÔ SENDO O PRIMEIRO CENTRAL DA LISTA –PARTIÇÃO). . 9
MERGE SORT ............................................................................................................... 10
HEAP SORT................................................................................................................... 10
Fontes – Imagens........................................................................................................... 12

2
 ALGORITMOS DE ORDENAÇÃO

BUBBLE SORT (VERSÃO ORIGINAL SEM MELHORIAS)

O Bubble Sort (Ordenação por Bolha) é um algoritmo de ordenação simples que

funciona comparando repetidamente pares adjacentes de elementos na lista e trocando-
os se estiverem fora de ordem. Esse processo de "borbulhamento" dos elementos
desloca gradualmente os maiores elementos para o final da lista e os menores para o
início, até que a lista esteja totalmente ordenada.

O Bubble Sort não é um algoritmo muito eficiente, especialmente para listas

grandes, pois sua complexidade de tempo no pior caso é de O(n^2), onde "n" é o número
de elementos na lista. Ele é mais usado para fins educacionais ou quando a simplicidade
do algoritmo é mais importante que a eficiência. Complexidade pior caso: O(n^2), caso
médio: O(n^2) e melhor caso: O(n).

3
 BUBBLE SORT MELHORADO (VERSÃO QUE VERIFICA SE O VETOR JÁ
ESTÁ ORDENADO)

O Bubble Sort melhorado que verifica se o vetor já está ordenado é uma variação
do Bubble Sort clássico que tenta otimizar o desempenho quando a lista já está parcial
ou completamente ordenada.

A principal diferença entre o Bubble Sort melhorado e o Bubble Sort clássico é a

verificação da variável “OcorreuTroca após cada passagem. Se em uma passagem
completa pela lista não ocorrerem trocas, isso significa que a lista já está ordenada e não
é mais necessário continuar a classificação, economizando tempo.

No melhor caso, quando a lista já está ordenada, o Bubble Sort melhorado executa
em tempo linear (O(n)), pois não precisa fazer trocas. No entanto, no pior caso (quando
a lista está inversamente ordenada), ele ainda possui a mesma complexidade de tempo
do Bubble Sort clássico, ou seja, O(n^2). Portanto, embora seja uma melhoria em relação
à versão clássica em casos específicos, o Bubble Sort melhorado ainda não é um dos
algoritmos mais eficientes para ordenação. Complexidade pior caso: O(n), caso médio:
O(n^2) e melhor caso: O(n).

INSERTION SORT

A principal ideia por trás do Insertion Sort é construir um subconjunto ordenado da

esquerda para a direita, onde cada elemento inserido é colocado na posição correta em
relação aos elementos já ordenados. Isso é semelhante a como alguém ordenaria cartas
de baralho à medida que as recebe, movendo cada carta nova para a posição correta em
relação às cartas já em ordem.

É um algoritmo de ordenação que classifica uma lista de elementos, como

números, de maneira incremental. Ele começa considerando o primeiro elemento da lista
como uma lista ordenada de um único elemento. Em seguida, ele passa para o segundo
elemento, que é considerado não ordenado no início.

4
 Para inserir o segundo elemento na lista ordenada, o algoritmo o compara com o
primeiro elemento. Se o segundo elemento for menor que o primeiro, eles são trocados
de posição, colocando o elemento menor na primeira posição e o elemento maior na
segunda. Agora, a lista ainda está ordenada porque só tem dois elementos.

Em seguida, o algoritmo avança para o terceiro elemento não ordenado e o

compara com os elementos na lista ordenada (que agora tem dois elementos). Ele
desloca os elementos maiores para a direita para abrir espaço e insere o terceiro
elemento na posição apropriada, de modo que a lista de três elementos ainda esteja
ordenada.

Esse processo continua para todos os elementos não ordenados na lista,

expandindo gradualmente a lista ordenada. A cada passo, o algoritmo insere um
elemento não ordenado na posição correta da lista ordenada, movendo os elementos
maiores (ou iguais) para a direita conforme necessário.

O algoritmo está completo quando todos os elementos tenham sido inseridos na

lista ordenada. A lista agora estará completamente ordenada.

O Insertion Sort é eficiente para listas pequenas ou quase ordenadas, pois requer
um número mínimo de comparações e trocas em comparação com algoritmos como o

5
Bubble Sort. No entanto, seu desempenho degrada rapidamente à medida que o
tamanho da lista aumenta. A complexidade de tempo média do Insertion Sort é O(n^2),
onde "n" é o número de elementos na lista, tornando-o menos adequado para listas
grandes. Complexidade pior caso: O(n^2), caso médio: O(n^2), melhor caso: O(n).

SHELL SORT

O Shell Sort é um algoritmo de ordenação que melhora o Insertion Sort ao dividir

a lista em grupos e ordená-los individualmente. Começa com lacunas maiores e,
gradualmente, as reduz. Isso reduz o número de trocas e melhora o desempenho,
especialmente em listas maiores. O processo continua até que a diferença entre os
elementos seja 1, quando ocorre a ordenação final.

6
 Embora o Shell Sort seja mais eficiente do que o Insertion Sort em muitos casos,
ele não é tão rápido quanto algoritmos de ordenação mais avançados, como o Merge
Sort ou o Quick Sort. No entanto, ele pode ser uma escolha sólida quando a simplicidade
de implementação é importante e a lista não é muito grande. Complexidade: pior caso:
O(n log2 n), caso médio: depende da sequência do gap, melhor caso: O(n log2 n).

SELECTION SORT

O Selection Sort é um algoritmo de ordenação que funciona selecionando

repetidamente o elemento mínimo da lista não classificada e movendo-o para a posição
apropriada na lista ordenada. O processo é iterativo: na primeira iteração, ele encontra o
menor elemento e o coloca na primeira posição; na segunda iteração, ele encontra o
próximo menor elemento e o coloca na segunda posição, e assim por diante. O algoritmo
continua até que todos os elementos estejam na posição correta na lista ordenada.

Embora o Selection Sort seja fácil de entender e implementar, ele não é eficiente
para listas muito grandes, pois seu desempenho tem uma complexidade de tempo no
pior caso de O(n^2), o que significa que o número de operações cresce rapidamente com
o tamanho da lista. Portanto, para listas maiores, outros algoritmos de ordenação, como
o Merge Sort ou o Quick Sort, são geralmente preferíveis devido à sua eficiência superior.
No entanto, o Selection Sort pode ser útil em situações em que a simplicidade de

7
implementação é mais importante do que o desempenho máximo. Complexidade pior
caso: O(n^2), caso médio: O(n^2) e melhor caso: O(n^2).

QUICK SORT (COM PIVÔ SENDO O PRIMEIRO ELEMENTO DA LISTA –

PARTIÇÃO)

O Quick Sort é um algoritmo de ordenação eficiente que segue a estratégia "dividir

para conquistar". Na versão com o pivô sendo o primeiro elemento da lista, ele começa
selecionando o primeiro elemento como pivô e divide a lista em duas sub-listas: uma com
elementos menores ou iguais ao pivô e outra com elementos maiores. Em seguida, o
algoritmo é aplicado recursivamente a essas sub-listas até que toda a lista esteja
ordenada. O processo de particionamento é crítico e envolve mover índices esquerdo e
direito para encontrar elementos que precisam ser trocados. Embora o Quick Sort seja
eficiente na maioria dos casos, sua escolha de pivô pode afetar o desempenho. O Quick
Sort tem uma complexidade média de tempo de O(n log n) e é amplamente usado em
ordenação rápida de listas.

Complexidade: pior caso: O(n^2), caso médio: O (n log n) e melhor caso: O (n log
n).
8
 QUICK SORT (COM PIVÔ SENDO O PRIMEIRO CENTRAL DA LISTA –
PARTIÇÃO).

No Quick Sort com o pivô sendo o elemento central da lista, a escolha do pivô é
feita selecionando o elemento central da lista como pivô. A lista é então particionada em
duas sub-listas: uma contendo elementos menores que o pivô e outra com elementos
maiores que o pivô. O processo de particionamento envolve a movimentação de índices
esquerdo e direito para encontrar elementos que precisam ser trocados. O algoritmo é
aplicado recursivamente a ambas as sub-listas até que toda a lista esteja ordenada. Esse
método ajuda a evitar degradações de desempenho em comparação com outras
escolhas de pivô, especialmente quando a lista já está parcialmente ordenada. É uma
variação eficiente do Quick Sort, seguindo a estratégia "dividir para conquistar".

Embora o Quick Sort com essa escolha de pivô seja eficiente na maioria dos casos,
seu desempenho pode ser menos eficiente do que outras variações do Quick Sort em
listas que já estão parcialmente ordenadas. Complexidade pior caso: O(n^2), caso médio:
O (n log n) e melhor caso: O (n log n).

9
 MERGE SORT

A ideia do Merge Sort é dividir o vetor em dois subvetores, cada um com metade
dos elementos do vetor original. Esse procedimento é então reaplicado aos dois
subvetores recursivamente. Quando os subvetores têm apenas um elemento (caso
base), a recursão para. Então, os subvetores ordenados são fundidos (ou intercalados)
num único vetor ordenado.

Complexidade equivalentemente, T(n)=O(nlogn). Essa complexidade é a mesma

no melhor caso, no caso médio e no pior caso.

HEAP SORT

O Heap Sort é um algoritmo de ordenação que utiliza uma estrutura de dados

chamada "heap" (ou heap binário). Essa estrutura é uma árvore binária especial onde
cada nó pai é maior (ou menor) do que seus filhos, dependendo do tipo de heap utilizado.
O Heap Sort começa construindo um heap máximo a partir da lista de elementos a serem
ordenados, garantindo que o maior elemento esteja na raiz da árvore. Após a construção
do heap máximo, o algoritmo ordena a lista trocando repetidamente o primeiro elemento
(raiz do heap) com o último elemento não ordenado da lista e, em seguida, reconstruindo
o heap máximo com o restante dos elementos. Esse processo é repetido até que toda a
lista esteja ordenada. O Heap Sort é eficiente e tem uma complexidade de tempo
10
garantida de O(n log n), independentemente da disposição inicial dos elementos na lista,
mas requer espaço adicional para armazenar a estrutura do heap.

Complexidade pior caso: O (n log n), caso médio: O (n log n) e melhor caso: O (n
log n).

11
Fontes – Imagens

Bubble Sort: o que é e como usar? Exemplos práticos! – Insights para te ajudar na
carreira em tecnologia | Blog da Trybe (betrybe.com)

Bubble sort – Wikipédia, a enciclopédia livre (wikipedia.org)

Insertion sort – Wikipédia, a enciclopédia livre (wikipedia.org)

Shell sort – Wikipédia, a enciclopédia livre (wikipedia.org)

Selection sort – Wikipédia, a enciclopédia livre (wikipedia.org)

Quicksort – Wikipédia, a enciclopédia livre (wikipedia.org)

https://www.blogcyberini.com/2018/07/merge-sort.html

Heapsort – Wikipédia, a enciclopédia livre (wikipedia.org)

.Net Helper: Bubble Sort (mannpandey.blogspot.com)

Flowchart Drawing Bubble Sort - Insertion Sort Algorithm Example , Transparent

Cartoon - Jing.fm

Shell Sort - Pencil Programmer

Shell Sort - Pencil Programmer

FACE Prep | The right place to prepare for placements

Implement Quicksort with first element as pivot - GeeksforGeeks

https://www.programmingboss.com/2016/02/quick-sort-algorithm-implementation-
in.html

https://www.programiz.com/dsa/merge-sort

12