Anlise e Complexidade d Al de Algoritmos it

Mtodos de Ordenao - seleo e insero - seleo e troca (bubble sort) - merge e quick i k sort t - radix - hashing
Prof. Rodrigo Rocha prof.rodrigorocha@yahoo.com http://www.bolinhabolinha.com

Onde Estamos
Ementa
Reviso:
Estrutura de dados;Crescimento de funes; Induo matemtica e mtodos matemticos matemticos.

Medidas de complexidade, anlise assinttica de limites de complexidades. Exemplos de anlise de algoritmo iterativos e recursivos. Anlise de desempenho de alguns algoritmos clssicos de busca e ordenao. Introduo aos principais paradigmas do projeto de algoritmos. Complexidade do Problema: Limites de Complexidade, Intratabilidade, Classes P, NP, problemas Np completos e NP-difceis.

Introduo
Atividade fundamental na computao Mtodo de rearranjar um conjunto de dados em ordem crescente ou decrescente Mtodos estudados:
Seleo (Selection sort) Insero (Insertion sort) Seleo e Troca (Bubble Sort) Intercalao (Merge Sort) Particionamento (troca) (QuickSort) Radix

Ordenao Interna
Simples Adequados para pequenos arquivos O(n2) Eficientes Arquivos maiores que requerem n(log n)

Seleo - Selection Sort

Um dos mtodos mais simples Funcionamento
Selecione o menor valor do vetor Troque com o item que est na 1. posio do vetor Repita esta operao para os n-1 itens restantes Depois repita para n-2, at restar apenas um elemento

Animao
http://www.cs.pitt.edu/~kirk/cs1501/animations/Sort3.html

Seleo - Selection Sort

Exemplo

Seleo - Selection Sort

Algortimo

Seleo - Selection Sort

Complexidade
(nmeros de troca) Melhor caso
entrada j ordenada O(n)

Pior caso
entrada na ordem inversa O(n2)

Caso C mdio di
O(n2)

Insero - Insertion Sort

Dividir os valores a serem ordenados em:
coleo U de valores desordenados (a serem ordenados) coleo S de valores ordenados

Remover um a um os valores de U e inser-los em S

Mantendo S ordenado

Incio:
U = conjunto desordenado de valores S = vazio

Termino:
U = vazio S = conjunto ordenado de valores

Insero - Insertion Sort

Para ordenar n valores, no vetor A[0:n-1]
Utilize A contendo subvetor S e U lado-a-lado S inicia no lado esquerdo de A U inicia no lado direito de A retire um valor V do final a esquerda de U
criar um espao entre S e U

mova todos os valores em S que forem maiores que V um espao a direita insira V no espao remanescente em S

Repetir at todos os valores em U estarem inseridos em S No final, S ocupa o mesmo espao que A

Insero - Insertion Sort

Insero - Insertion Sort

Algoritmo

Insero - Insertion Sort

Complexidade
Melhor caso
entrada j ordenada O(n)

Pior caso
entrada na ordem inversa O(n2)

Caso mdio
O(n2)

Insero - Insertion Sort

Animao na web
http://www http://www.cs.oswego.edu/~mohammad/classes/c cs oswego edu/ mohammad/classes/c sc241/samples/sort/Sort2-E.html http://www.ece.unb.ca/brp/lib/java/insertionsort/ http://www.oopweb.com/Algorithms/Documents/A nimatedAlgorithms/VolumeFrames.html

Seleo e Troca - Bubble sort

Funcionamento
Varrer o vetor V comparando os elementos adjascentes v[i], v[i+1] v[i 1] Se v[i]>v[i+1] troque v[i] por v[i+1] at nenhuma troca ser necessria

Em cada passo
maior valor empurrado para o fim item(s) no final do vetor esto ordenados menor valor movido uma posio a menos no final

Seleo e Troca - Bubble sort

Vetor A =18 26 3 9 34 5 21 14 6 Passo 1:
A A A A A A A A A =(18 = 18 = 18 = 18 = 18 = 18 = 18 = 18 = 18 26) 3 9 34 5 21 14 6 (26 3) 9 34 5 21 14 6 3 (26 9) 34 5 21 14 6 3 9 (26 34) 5 21 14 6 3 9 26 (34 5) 21 14 6 3 9 26 5 (34 21) 14 6 3 9 26 5 21 ( (34 14) ) 6 3 9 26 5 21 14 (34 6) 3 9 26 5 21 14 6 | 34 ok troca troca ok troca troca troca troca

Entre parnteses esto as comparaes SubLista contm o ltimo valor 34, e est ordenado

Seleo e Troca - Bubble sort

Passo 2:
A A A A A A A A A = = = = = = = = = (18 3) 9 26 5 21 14 6 | 34 3 (18 9) 26 5 21 14 6 | 34 3 9 (18 26) 5 21 14 6 | 34 3 9 18 (26 5) 21 14 6 | 34 3 9 18 5 (26 21) 14 6 | 34 3 18 9 5 21 (26 14) 6 | 34 3 18 9 5 21 14 (26 6) | 34 3 18 9 5 21 14 6 (26 | 34) 3 18 9 5 21 14 6 | 26 34 troca troca ok troca troca troca troca ok

subLista que contm os dois ltimos valores 26 34 esto ordenados

Seleo e Troca - Bubble sort

Passo 3:
A A A A A A A A A = = = = = = = = = (3 18) 9 5 21 14 6 | 26 34 3 (18 9) 5 21 14 6 | 26 34 3 9 (18 5) 21 14 6 | 26 34 3 9 5 (18 21) 14 6 | 26 34 3 9 5 18 (21 14) 6 | 26 34 3 9 5 18 14 (21 6) | 26 34 3 9 5 18 14 6 (21 | 26) 34 3 9 5 18 14 6 21 | (26 34) 3 9 5 18 14 6 | 21 26 34 ok troca t troca ok troca troca ok ok

subLista que contm os dois ltimos valores 21 26 34 esto ordenados Depois do passo i, o ltimo valor de i est ordenado

Seleo e Troca - Bubble sort

(Aps) Passo 4:
A =3 5 9 14 6 | 18 21 26 34

(Aps) Passo 5:
A =3 5 9 6 | 14 18 21 26 34

(Aps) Passo 6:
A = 3 5 6 | 9 14 18 21 26 34

(Aps) Passo 7:
A = 3 5 6 | 9 14 18 21 26 34

Terminado !!! nenhuma troca necessria

Seleo e Troca - Buble Sort

static void bubbleSort(int vet[]) { int passo,j,temp; p ,j, p; //contador dos passos de 1 at o tamanho do vetor for (passo=1;passo<vet.length;passo++) // passa por todos comparando o menor for (j=0;j<vet.length-passo;j++) if (vet[j]>vet[j+1]) { // troca os elementos temp = vet[j+1]; vet[j+1] = vet[j]; vet[j]=temp; } }

Seleo e Troca - Bubble sort

Nmero de comparaes
Para 9 valores: 8 primeiro passo, 7 no segundo, 6 no terceiro, . 8+7+6+5+4+3+2+1 = 36 (comparaes) Para n valores: (n-1) primeiro passo, (n-2) segundo passo, (n-1) + (n-2) + . + 1 = n * (n+1)/2 (comparaes) Nmero de comparaes: n * (n+1)/2 = (n2 + n)/2

10

Seleo e Troca - Bubble sort

Melhor Caso
vetor j ordenado (n-1) comparaes comparaes, nenhuma troca

Caso mdio
metade do tempo n(n+1)/4 proporcional a n2

Pior o Caso
vetor ordenado decrescente uma troca por comparao n(n+1)/2 = O(n2)

Seleo e Troca - Bubble sort

Animao na web
http://www.cs.oswego.edu/~mohammad/classes/c sc241/samples/sort/Sort2 E.html sc241/samples/sort/Sort2-E.html http://www.ece.unb.ca/brp/lib/java/bubblesort/ http://www.cosc.canterbury.ac.nz/people/mukund an/dsal/BSort.html /d l/BS t ht l

11

Merge sort
Refinamento da estretgia de dividir para conquistar Para ordenar n valores em um vetor A[0:n-1], na ordem ascendente:
1. Dividir a seqncia A em duas metades, esquerda E e direita D 2. MergeSort a seqncia esquerda E 3. MergeSort a seqncia direira D Unir as seqncias direita e esquerda em um resultado S Utilizar recursividade para ordenar os dois lados O corao do MergeSort o passo de unio

Merge sort
Passo de unio
Assumimos duas seqncias ordenadas D e E Para juntar os valores de D e E em uma nova seqncia ordenada S
repetidamente
1. compare os valores iniciais de D e E 2. coloque o menor em S 3. (Se uma das seqncias estiver vazia, copiar os elementos restantes dentro de S

Resultado:
S contm todos os elementos de D e E ordenados

12

Merge sort
MergeSort A =18 26 3 9 34 5 21 14 6
Divide A: E = 18 26 3 9 e D =34 5 21 14 6 MergeSort E:
Divide E: EE = 18 26 e ED =3 9 MergeSort EE:
Divide EE: EEE = 18 e EED = 26 MergeSort EEE: ( j est ordenado) MergeSort EED: (j est ordenado) Merge 18 (EEE ordenado) e 26 (EED ordenado): Resultado: 18 26

MergeSort ED: ... Resultado: 3 9 Merge 18 26 (EE ordenado) e 3 9(ED ordenado): Resultado: 3 9 18 26

MergeSort D: ... Resultado: 5 6 14 21 34

Merge 3 9 18 26(E ordenado) e 5 6 14 21 34(D ordenado): Resultado: 3 5 6 9 14 18 21 26 34

Merge sort - exemplo

13

Merge sort - exemplo

Merge sort - exemplo

14

Merge sort - exemplo

Merge sort - exemplo

15

Merge Sort
void mergesort(int a[ ], int low, int high) { if(low == high) return; int length = high-low+1; int pivot = (low+high) / 2; mergesort(a, low, pivot); mergesort(a pivot+1 mergesort(a, pivot+1, high); int working[ ] = new int[length]; for(int i = 0; i < length; i++) working[i] = a[low+i]; int m1 = 0; int m2 = pivot-low+1; for(int i = 0; i < length; i++) { if(m2 <= high-low) if(m1 <= pivot-low) if(working[m1] ( g[ ] > working[m2]) g[ ]) a[i+low] = working[m2++]; else a[i+low] = working[m1++]; else a[i+low] = working[m2++]; else a[i+low] = working[m1++]; } }

Merge sort
Estratgia
Dividir um vetor A de n elementos em duas metades (vetores) E[0:meio] e D[meio+1:n-1] Combinar as metades ordenadas E e D unindo-as em um nico resultado ordenado Ateno
requer um vetor adicional de tamanho igual ao que ir ser ordenado se somente o vetor original ocupa toda memria, merge sort no ir funcionar se voc tem bastante espao, merge sort a melhor escolha

Complexidade
Caso mdio
O(n log n)

Pior caso
O(n log n)

16

Merge sort Animaes na web

http://www.geocities.com/SiliconValley/Program/2 864/File/Merge1/mergesort.html http://wwwcse.uta.edu/~holder/courses/cse2320/lectures/ap plets/sort1/mergesort_df.html

Merge Sort
1-) Simular o processo do algoritmo de ordenao Merge Sort para o seguinte conjunto de valores:
10,3,6,12,33,21,56,2,13,1

2-) Implementar o algoritmo de merge sort e test-lo.

17

Quick sort
QuickSort foi descoberto em 1962. Refinamento do algoritmo de dividir para conquistar Para ordenar n valores em um vetor A[0:n-1], na ordem ascendente:
1. Particionar a seqncia A em direita D e esquerda E utilizando um valor de A como piv 2. QuickSort a poro esquerda E. 3. QuickSort a poro direita D.

Utilizar recursividade para ordenar os dois lados

At uma seqncia de 1 elemento elemento, que est ordenada

o corao do QuickSort o passo de Particionar partir o vetor em dois sub vetores, tal que todos os elementos do primeiro sejam menores ou iguais a todos os elementos do segundo

Particionamento dos dados

Particionando
Para particionar os dados, dividimos em dois grupos selecionamos um piv
podemos utilizar diversas tcnicas (exemplo: meio do vetor)

percorro o vetor de baixo para cima at achar um valor que seja maior que o piv percorro o vetor de cima para baixo at achar um valor que seja menor que o piv troca troca-se se os dois elementos (aquele que no era menor que o piv com aquele que no era maior que o piv) trmino = quando os percursos se cruzarem:
dois grupos, um abaixo do piv, com elementos menor que este outro acima do piv, com elementos maiores que este

18

Quick sort - particionamento

Quick sort - particionamento

19

Quick sort - particionamento

Quick sort - particionamento

20

Quick sort - particionamento

Exemplo

21

Quick sort
Algoritmo
void quicksort (int[] a, int lo, int hi) {
// lo o ndice mais baixo, hi o ndice mais alto // da regio do vetor que ir ser ordenada

int i=lo, i=lo j=hi, j=hi h; int x=a[(lo+hi)/2]; // particionamento do { while (a[i]<x) i++; while (a[j]>x) j--; if (i<=j) { h=a[i]; a[i]=a[j]; a[j]=h; i++; j--; } } while (i<=j); // recurso if (lo<j) quicksort(a, lo, j); if (i<hi) quicksort(a, i, hi); }

Quick sort
Complexidade
melhor caso (a)
cada particionamento produz duas partes de tamanhos iguais O(n log n) - log n cada metade

Caso mdio O(n log n) Pior Caso (c)

Pivo o maior ou menor valor da partio
Passo de particionamento separa n valores em grupos de um valor, e os grupos contm n-1 valores)O(n2)

QuickSort muito sensvel a escolha do Pivo

22

 Animaes na web
http://www http://www.cs.oswego.edu/~mohammad/classes/c cs oswego edu/~mohammad/classes/c sc241/samples/sort/Sort2-E.html

http://wwwcse.uta.edu/~holder/courses/cse2320/lectures/ap t d / h ld / / 2320/l t / plets/quicksort/

Radix sort

Rearranjar o vetor baseado na representao inteira dos dgitos individuais

inteiros caracteres decimais (preparados) datas

dois tipos
least significant digit (LSD)
dgito menos significativo

most significant digit (MSD)

dgito mais significativo

23

Radix sort

Processo do LSD
Pegue o ltimo digito mais significativo de cada chave Agrupe as chaves baseado no dgito, mantendo a ordem original g das chaves repita o processo para os outros dgitos mais significativos

Exemplo
Original, lista desordenada: 170, 45, 75, 90, 2, 24, 802, 66 Ordenando pelo ltimo digito (unidade)
170 90 170, 90, 2 2, 802 802, 24 24, 45 45, 75 75, 66

Ateno: 2 est antes do 802, pois ele ocorre antes na lista original. Assim como o 170 e 90. Ordenando o prximo dgito (dezena)
2, 802, 24, 45, 66, 170, 75, 90 2, 24, 45, 66, 75, 90, 170, 802

Ordenando pelo prximo dgito (centena)

Radix sort Complexidade

temos
n total de elementos m o valor mximo de um conjunto de elementos
exemplo sistem decimal de 0 a 9, logo 10 digitos m=10

p o nmero de iteraes, depende da quantidade de dgitos, de 0 a 999 p=3

O(m*p) e O(n*p) = O(p(n+m))

m e p so pequenos no caso de sistema decimal m=10 e p<=10

O(n)

24

Radix sort
Animaes na web
http://wwwcse.uta.edu/ holder/courses/cse5311/lectures/ap cse.uta.edu/~holder/courses/cse5311/lectures/ap plets/radix/RadixSort.html

http://www.cse.iitk.ac.in/users/dsrkg/cs210/applet s/sortingII/radixSort/radixSort html s/sortingII/radixSort/radixSort.html http://www.cs.umass.edu/~immerman/cs311/appl ets/vishal/RadixSort.html

Exerccios
Modifique o programa selection sort para sempre jogar o maior elemento para o final, ao invs do menor para o comeo. A complexidade mudou? Justifique. Modifique o programa selection sort para ordenar de forma decrescente

25

Exerccios
1-) Considerando os vetores abaixo:
a-) [ 10, 1, 9, 2, 8, 3 ] b-) [ 8,9,7,9,3,2,3,8,4,6 ] c-) [ 1,4,6,8,12,11 ] d-) [ 13,33,43,53,63 ]

Desenhe a seqncia de passos realizados para orden-los, utilizando os mtodos de busca insertion sort e bubble sort. Qual a complexidade de cada ordenao para cada vetor?

2-) Se para cada comparao feita no algoritmo de ordenao bubble sort, voc realiza-se uma busca seqencial, com que complexidade ficaria este novo algoritmo? 3-) Se a busca implementada no exerccio 2 fosse binria, a complexidade mudaria? Justifique. 4-) Um programador desconfiado, achou melhor implementar em cada iterao do insertion sort (no vetor parcialmente ordenado S), uma verificao, para isso, executa o procedimento de ordenao bubble sort na parte ordenada pelo insertion sort. Voc acredita que foi uma boa escolha ? Justifique ?

Exerccios 1-) Simular a ordenao por quick sort no seguinte conjunto de valores:
7, 7 1, 1 3, 3 9, 9 8 8, 4, 4 2, 2 7 7, 4 4, 2 2, 3 3, 5 5.

2-) Implementar o algoritmo de quick sort e test-lo.

26

Radix sort
Exerccio
Ordenar utilizando radix sort os seguintes conjuntos:
a-)

45 93 38 74 39 32 72 14 92 5 91 66

Radix sort
Exerccio
Ordenar utilizando radix sort os seguintes conjuntos:
b-) 111
12 11 1 33 22 112 2 96 55 14 66

27

Radix sort Exerccio

c c-) ) Como ficaria a implementao do Radix para ordenao de palavras? D um exemplo de ordenao de palavras com at 3 letras. Como ficou a complexidade, ela mudou ?

Bibliografia

Livro texto
ZIVIANI, Nivio. Projeto de Algoritmos : com implementao em Pascal e C.. 2 ed. So Paulo: Pioneira Thomson Learning, 2004. , Paulo A. S.. Estrutura de Dados. 1 ed. So Paulo: Campus, p , VELOSO, 1983. CORMEN, Thomas H. Algoritmos : teoria e prtica. 1 ed. Rio de Janeiro: CAMPUS, 2002.

Complementar
SCHILDT, Herbert. C Completo e Total. 3 ed. So Paulo: Pearson Education, 2005. CELES, Waldemar; CERQUEIRA, Renato. Introduo a Estruturas de Dados : com tcnicas de programao em C. 4 ed. Rio de Janeiro: Elsevier, 2004 WIRTH, Niklaus. Algoritmos e Estruturas de Dados. 1 ed. Rio de Janeiro: LTC, 1989 TENENBAUM, Aaron M; SOUZA, Tereza Cristina Flix de. Estruturas de Dados usando C. 1 ed. So Paulo: Makron Books,1995.

28