ALGORITMOS E ESTRUTURAS DE DADOS

Prof Guto Garcia

Algoritmos de Ordenao

Kaique Silva
Soraya Bonaf

BUBBLE SORT
Bubble sort o algoritmo mais simples, mas o menos eficientes. Neste algoritmo cada elemento
da posio i ser comparado com o elemento da posio i + 1, ou seja, um elemento da posio 2
ser comparado com o elemento da posio 3. Caso o elemento da posio 2 for maior que o da
posio 3, eles trocam de lugar e assim sucessivamente. Por causa dessa forma de execuo, o

vetor ter que ser percorrido quantas vezes que for necessria, tornando o algoritmo ineficiente
para listas muito grandes.
Algoritmo em Python:
def bubbleSort(V):
if len(V) <= 1:
sA = V
else:
for j in range(0,len(V)):
for i in range(0,len(V)-1):
if V[i]>V[i+1]:
Aux = V[i+1]
V[i+1] = V[i]
V[i] = Aux
sA = V
return sA

Tempo de execuo: 33,65 segundos

Utilizando-se um vetor com 10.000 elementos aleatoriamente gerado.
Funcionamento (chins):

V[0] > V[1] = False

Ento no h troca de posio.

V[1] > V[2] = True

Ento V[1] troca de posio com V[2]

V[2] > V[3] = True

Ento V[2] troca de posio com V[3]

V[3] > V[4] = True

Ento V[3] troca de posio com V[4]

Chegando ao final do vetor, o mtodo retorna ao incio, realizando os mesmos procedimentos de

comparao, at que o vetor esteja completamente ordenado.

INSERTION SORT
O Insertion sort um algoritmo simples e eficiente quando aplicado em pequenas listas. Neste
algoritmo a lista percorrida da esquerda para a direita, medida que avana vai deixando os
elementos mais esquerda ordenados.
Algoritmo em Python:
def insertionSort(V):
for j in range(1, len(V)):
chave = V[j]
i=j-1
while i >= 0 and V[i] > chave:
V[i + 1] = V[i]
i -= 1
V[i + 1] = chave

Tempo de execuo: 11,22 segundos

Utilizando-se um vetor com 10.000 elementos aleatoriamente gerado.

SELECTION SORT
Este algoritmo baseado em se passar sempre o menor valor do vetor para a primeira posio
(ou o maior dependendo da ordem requerida), depois o segundo menor valor para a segunda
posio e assim sucessivamente, at os ltimos dois elementos.
Neste algoritmo de ordenao escolhido um nmero a partir do primeiro, este nmero
escolhido comparado com os nmeros a partir da sua direita, quando encontrado um nmero
menor, o nmero escolhido ocupa a posio do menor nmero encontrado. Este nmero
encontrado ser o prximo nmero escolhido, caso no for encontrado nenhum nmero menor
que este escolhido, ele colocado na posio do primeiro nmero escolhido, e o prximo
nmero sua direita vai ser o escolhido para fazer as comparaes. repetido esse processo at
que a lista esteja ordenada.

def selectSort (V):

n=len(V)
for i in range(n-1):
mini = i
for j in range(i+1,n):
if(V[j]<V[mini]):
mini=j
V[i],V[mini]=V[mini],V[i]

Tempo de execuo: 11,56 segundos

Utilizando-se um vetor com 10.000 elementos aleatoriamente gerado.

MERGE SORT
O merge sort, ou ordenao por mistura, um exemplo de algoritmo de ordenao do tipo
dividir-para-conquistar.
Sua ideia bsica consiste em Dividir(o problema em vrios sub-problemas e resolver esses subproblemas atravs da recursividade) e Conquistar(aps todos os sub-problemas terem sido
resolvidos ocorre a conquista que a unio das resolues dos sub-problemas).Como o algoritmo

do Merge Sort usa a recursividade em alguns problemas esta tcnica no muito eficiente devido
ao alto consumo de memria e tempo de execuo.
Os trs passos teis dos algoritmos dividir-para-conquistar, ou divide and conquer, que se
aplicam ao merge sort so:
Dividir: Dividir os dados em subsequncias pequenas;
Conquistar: Classificar as duas metades recursivamente aplicando o merge sort;
Combinar: Juntar as duas metades em um nico conjunto j classificado.
def mergeSort(V):
if len(V)>1:
mid = len(V)//2
lefthalf = V[:mid]
righthalf = V[mid:]
mergeSort(lefthalf)
mergeSort(righthalf)
i=j=k=0
while i<len(lefthalf) and j<len(righthalf):
if lefthalf[i]<righthalf[j]:
V[k]=lefthalf[i]
i=i+1
else:
V[k]=righthalf[j]
j=j+1
k=k+1
while i<len(lefthalf):
V[k]=lefthalf[i]
i=i+1
k=k+1
while j<len(righthalf):
V[k]=righthalf[j]
j=j+1
k=k+1

Tempo de execuo: 0,13 segundos

Utilizando-se um vetor com 10.000 elementos aleatoriamente gerado.

QUICK SORT

O Quicksort o algoritmo mais eficiente na ordenao por comparao. Nele se escolhe um

elemento chamado de piv, a partir disto organizada a lista para que todos os nmeros
anteriores a ele sejam menores que ele, e todos os nmeros posteriores a ele sejam maiores que
ele. Ao final desse processo o nmero piv j est em sua posio final. Os dois grupos
desordenados recursivamente sofreram o mesmo processo at que a lista esteja ordenada.

def qsort1(V):
if V == []:
return []
else:
pivot = V[0]
lesser = qsort1([x for x in V[1:] if x < pivot])
greater = qsort1([x for x in V[1:] if x >= pivot])
return lesser + [pivot] + greater