INSTITUTO SUPERIOR DE TRANSPORTES E COMUNICAES

DEPARTAMENTO DE CINCIAS BSICAS

Algoritmos e Estrutura de Dados

Trabalho de Investigao

TEMA : Algoritmo Quicksort

Docente:
Incio Ticongolo

Discentes:
Ivan Ernesto
Ruy Alexandre Dombo
Wilton Baltazar
Kevin Faftine
Nuno Barbosa

Maputo, Marco de 2015

Introduo
O presente trabalho vem debruar-se sobre Os Algoritmos de Ordenao, mais concretamente o
algoritmo de ordenao Quicksort, que basicamente um algoritmo que conhecido pelo lema de
dividir para conquistar.
Tem como objectivo explicar o funcionamento e oferecer um exemplo funcional do algoritmo acima
mencionado. Este trabalho est organizado em cinco partes que consistem, definio, como
realizada a organizao/escolha, conceito de Pivot e Diviso, complexidade do algoritmo, um
exemplo e por fim consideraes que devem ser tomadas no mbito da escolha deste algoritmo.
A metodologia utilizada foi a pesquisa bibliogrfica com bases na Internet.

Definio
Como j foi acima mencionado, Quicksort aquele que que divide um array em dois pequenos
arrays e por sua vez este faz a escolha/ordenao das duas pequenos arrays.
Para que isso seja possvel, vital que:

Seja seleccionado um elemento pivot e com tendncia a ser o elemento central;

Nos dois terminais, fazer a troca de elementos que satisfaam a condio de ser menores
que o elemento PIVOT pela esquerda e maiores que o PIVOT pela direita;
De forma forma recursiva se escolha ou se faca a seleco da parte esquerda e parte direita.

Conceito de PIVOT and Diviso

No existe nenhuma regra que defina que deve ser exatamente o elemento do meio o elemento
PIVOT, admitindo dessa forma que qualquer elemento do array desde que se tome em considerao
de que a maneira com se escolhe os elementos condiciona para complexidade do algoritmo
tornando-o mais pesado e complicado de se compreender, para ele de passar uma boa parte do
tempo alocado a CPU.

Como a seleo feita

Comparando com os outros algoritmos o Quicksort melhor, visto que o processo de diviso em
dois arrays torna mais eficiente o processo. Para perceber isto nada melhor que apreciar por
imagens que podem descrever o funcionamento do mesmo.
1. Primeiro Passo Determinar o elemento PIVOT

2. Segundo passo Posicionar os apontador de posio e iniciar a comparao, onde j foi dito
que o que menor que o elemento PIVOT se situa a esquerda e o que maior a direita.

3. Terceiro Passo - Uma vez que 5>3, trocar o apontador direito para esquerda e uma vez que
3 == 3, parar

4. Quarto Passo J foi feita e confirmada a verificao, efetuar agora a troca.

5. Quinto Passo Mover os apontadores mais casa

6. Sexto-Passo Uma vez que 2<3 deslocar o apontador esquerdo e uma vez 4>3, parar.

Complexidade em um Algoritmo Quicksort

Em um algoritmo Quicksort mdio tem a complexidade de O (nlogn) e na pior das hipteses ele tem
O (n), quando os elementos do array de entrada j so classificadas em ordem crescente ou
decrescente. Boa coisa sobre Quicksort que um algoritmo no lugar, o que significa que ele no
toma qualquer espao adicional, exceto aqueles usados pelo mtodo de pilha.
Existem alguns truques para melhorar o desempenho do Quicksort, mesmo no pior caso. Pode-se
aplicar seguinte recomendao para melhorar o algoritmo Quicksort implementao:

A aleatorizao pode-se evitar pior desempenho caso de O (n), quando a classificao de

dados quase-ordenadas por permutao aleatria das chaves. Apesar de incorrer em alguns
custos de permutao, mas ainda d um melhor desempenho do que O (n)
Deixar os pequenos arrays para serem resolvidos por via Insertion Sort desde que o numero
de elementos seja menor que 20.

Exemplo
public class QuickSort {
public static void main(String[] args) {
int[] x = { 9, 2, 4, 7, 3, 7, 10 };
printArray(x);
int low = 0;
int high = x.length - 1;
quickSort(x, low, high);
printArray(x);
}
public static void quickSort(int[] arr, int low, int high) {
if (arr == null || arr.length == 0)
return;
if (low >= high)
return;
//pick the pivot
int middle = low + (high - low) / 2;
int pivot = arr[middle];
//make left < pivot and right > pivot
int i = low, j = high;
while (i <= j) {
while (arr[i] < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
//recursively sort two sub parts
if (low < j)
quickSort(arr, low, j);
if (high > i)
quickSort(arr, i, high);
}
public static void printArray(int[] x) {
for (int a : x)
System.out.print(a + " ");
System.out.println();
}
}

Desvantagens do Quicksort
H uma desvantagem de usar recurso para implementar o algoritmo Quicksort, no vai escalar,
porque JVM no tem otimizao de chamada de cauda, ele simplesmente vai crescer a pilha de
chamada de mtodo para algo proporcional matriz para classificar, e ele ir falhar para disposio
muito grande.

Concluso

O Quicksort um dos mais populares algoritmos de ordenao considera-se como sendo

aproximado ao Bubble sort mas, com diferena o Quicksort suporta mais de vinte elementos e ainda
mantem uma complexidade considervel.