Algoritmos de Ordena c ao

Leandro A. Boscariol

Lucas B. Gameiro

Rodrigo L. S. Arruda

14 de agosto de 2007

Sum ario

Resumo Abstract 1 Bubble Sort 1.1 1.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.1 1.2.2 1.2.3 2 Quick Sort 2.1 2.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.1 2.2.2 2.2.3 Melhor caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pior caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caso m edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Melhor caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pior caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caso m edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 7 p. 7 p. 8 p. 8 p. 8 p. 9 p. 10 p. 10 p. 11 p. 11 p. 11 p. 12 p. 13 p. 13 p. 15

3 Merge Sort 3.1 3.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.2.1 3.2.2 4 Heap Sort 4.1 4.2

Melhor caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pior caso e caso m edio . . . . . . . . . . . . . . . . . . . . . . . .

p. 15 p. 15 p. 16 p. 16 p. 17 p. 18 p. 18 p. 19 p. 19 p. 19 p. 19 p. 20 p. 20 p. 21 p. 21 p. 21 p. 22 p. 22 p. 23 p. 23 p. 24

Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5 Count Sort 5.1 5.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.1 5.2.2 5.2.3 6 Radix Sort 6.1 6.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.1 6.2.2 Melhor Caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caso M edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Melhor Caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pior Caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caso M edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7 Bucket Sort 7.1 7.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1 Caso M edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8 Insertion Sort

8.1 8.2

Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.1 8.2.2 8.2.3 Melhor Caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pior Caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caso M edio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

p. 24 p. 25 p. 25 p. 25 p. 25 p. 26 p. 26 p. 26 p. 27 p. 28 p. 30 p. 33 p. 35 p. 36 p. 37 p. 38 p. 39 p. 40

9 Selection Sort 9.1 9.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An alise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Refer encias Bibliogr acas Ap endice A -- Implementa c ao do Bubble Sort Ap endice B -- Implementa c ao do Quick Sort Ap endice C -- Implementa c ao do Merge Sort Ap endice D -- Implementa c ao do Heap Sort Ap endice E -- Implementa c ao do Radix Sort Ap endice F -- Implementa c ao do Bucket Sort Ap endice G -- Implementa c ao do Count Sort Ap endice H -- Implementa c ao do Insertion Sort Ap endice I -- Implementa c ao do Selection Sort

Resumo
A cria c ao e implementa c ao de algoritmos de ordena c ao e um tema recorrente na ci encia da computa c ao. Tal tema atrai os pesquisadores pela simplicidade da elabora c ao de seu problema: ordenar certa lista de itens compar aveis, e pela variedade e complexidade alcan cadas pelas solu c oes propostas at e ent ao. Na literatura encontramos uma innidade de m etodos(algoritmos) de ordena c ao e neste trabalho apresentamos nove, dentre os mais populares e utilizados. Os algoritmos de ordena c ao s ao um campo f ertil para estudo de complexidade computacional nos diferentes casos de entrada e implementa c ao.

Abstract
The design and implementation of sorting algorithms is a recurrent subject in computer science. Such subject atracts researchers mainly by the simplicity of the proposed problem: to sort an unordered list, and by the variety and complexity reached by the solutions created so on. We found an large amount number of diferent sorting algorithms and in the present work we will discuss nine of them, amoung the most popular and used. The sorting algorithms are a great eld for computational complexity study using distinct inputs and implementations tecniques.

Bubble Sort

1.1

Algoritmo

O Bubble sort e um algoritmo de ordena c ao simples e ineci ente. Ele trabalha comparando cada elemento da lista com o pr oximo e efetua a troca caso estejam fora de ordem, quando n ao h a mais nenhuma troca realizada o algoritmo para e a lista est a ordenada. Este algoritmo recebeu este nome em analogia a bolhas(bubble) que, sendo mais leves que a agua, utuam at e a supercie. Assim como os n umeros menores que utuam at eo m da lista sendo ordenada. O algoritmo pode ser expressado de duas formas, a ver: Bubble sort: pseudo-c odigo 1 Seja A, uma lista de itens orden aveis. Fa ca: Trocou = falso Para i = 1 at e tamanho( A ) - 2 fa ca: Se A[ i ] > A[ i + 1 ] ent~ ao Trocar( A[ i ], A[ i + 1 ] ) Trocou = verdade Fim se Fim para Enquanto Trocou

Bubble sort: pseudo-c odigo 2 Seja A, uma lista de itens orden aveis. Para i = 1 at e tamanho( A ) fa ca: Para j = tamanho( A ) at e i + 1 fa ca: Se A[ j ] < A[ j - 1 ] ent~ ao Trocar( A[ j ], Fim se Fim para Fim para A[ j - 1 ] )

1.2
1.2.1

An alise
Melhor caso

O segundo formato apresentado do bubble sort tem uma complexidade sempre (n2 /2), pois os dois loops s ao executados com o n umero de passos dependente apenas do tamanho da entrada e n ao da qualidade da entrada. O primeiro formato apresentado, entretanto, tem no melhor caso - a entrada j a ordenada - (n), pois n ao haver a nenhuma troca, logo, apenas um la co mais interno com n itera c oes, j a que o mais externo ter a somente uma itera c ao.

1.2.2

Pior caso

O pior caso do bubble sort, falando do primeiro formato, e a lista ordenada de forma inversa aonde todas as trocas poss veis ter ao de ser realizadas produzindo uma complexidade (n2 /2). Neste pior caso o primeiro formato e ao eci ente quanto o segundo.

1.2.3

Caso m edio

O caso m edio, aonde a entrada e aleat oriamente distribuida, o bubble sort n ao e eci ente. Sua complexidade ca um pouco abaixo de (n2 /2), que e polinomial mas ainda sim de uma eci encia pobre quando comparada a outros algoritmos de ordena c ao muito melhores.

10

Quick Sort

2.1

Algoritmo

Desenvolvido pelo cientista da computa c ao brit anico Charles Antony Richard Hoare, o Quick Sort e um algoritmo de compara c ao que emprega a estrat egia de solu c ao de problemas dividir para conquistar. Este algoritmo na pr atica e mais eci ente que os seus concorrente porque o seu loop interno pode ser implementado de forma muito eci ente na maioria das arquiteturas, al em de ser poss vel fazer muitas decis oes de projeto para otimizar a ordena c ao para casos reais mais espec cos. Basicamente a opera c ao do algotitmo pode ser resumida na seguinte estrat egia: o Quick Sort divide sua lista de entrada em duas sub-listas a partir de um piv o, para em seguida realizar o mesmo procedimento nas duas listas menores at e o caso trivial de uma lista unit aria. De forma mais sistem atica, os passos da ordena c ao s ao: 1. Verica se n ao e um caso base: lista unit aria ou vazia, nestes casos a entrada ja est a trivialmente ordenada. 2. Escolhe um elemento da lista chamado piv o. 3. Reorganiza a lista de forma que os elementos menores que o piv o quem de um lado, e os maiores quem de outro. Esta opera c ao e chamada de particionamento. 4. Recursivamente ordena a sub-lista abaixo do piv o e acima do piv o.

11

O pseudo-c odigo do Quick Sort esta apresentado a seguir, mas abstraindo a escolha do piv o, que e algo muito dependente do tipo de aplica c ao.

Fun c~ ao Quicksort(Lista A) Lista menores, pivos, maiores Se tamanho(A) = 1 Retornar A Selecionar um valor piv^ o pivo de A Para cada x em A Se x < pivo ent~ ao Adicionar x a menores Se x = pivo ent~ ao Adicionar x a pivos Se x > pivo ent~ ao Adicionar x a maiores Retornar concatenar(Quicksort(menores), pivos, Quicksort(maiores)) ou tamanho(A) = 0

2.2
2.2.1

An alise
Melhor caso

O Quick Sort no melhor caso sempre escolhe o elemento mediano da sua lista de entrada como piv o, produzindo duas sub-listas que ser ao recursivamente ordenadas de mesmo tamanho. A arvore de recurs ao tem, neste caso, um tamanho de log n, sendo as folhas os casos base(triviais). E como, a cada itera c ao o algoritmo tem um trabalho de (n), temos que o tempo no melhor caso e (nlogn).

2.2.2

Pior caso

O pior caso do Quick Sort e justamente na pior escolha do piv o: um elemento extremo da lista(no inicio ou no nal). Desta forma o tamanho da arvore ser a n, pois cada elemento e um n o da arvore. E portanto, como ja sabemos que o tempo em uma itera c ao e (n), o tempo no pior caso e (n2 ).

12

2.2.3

Caso m edio

Pesquisas com entradas aleat orias e piv o escolhidos aleatoriamente mostram que a complexidade do Quick Sort, mesmo nestes casos, se aproxima muito do tempo de (nlogn), sendo tomado como refer encia na literatura como o tempo do caso m edio do Quick Sort. Esta e uma forte raz ao pela qual o Quick Sort e chamado(como batizado) de um algoritmo de ordena c ao muito r apido.

13

Merge Sort

3.1

Algoritmo

Criado em 1945 pelo matem atico americano John Von Neumann o Merge Sort e outro exemplo de um algoritmo de ordena c ao que faz uso da estrat egia dividir para conquistar para resolver problemas. O Merge Sort parte dos seguintes princ pios para solucionar o problema de ordena c ao: Menos passos s ao necess arios para ordenar uma lista menor. mais f E acil construir uma lista ordenada a partir de duas listas j a ordenadas a de duas n ao ordenadas. Logo, ele pode ser conceitualmente descrito nos seguintes passos: 1. Verica se n ao e um caso base: lista unit aria ou vazia, nestes casos a entrada ja est a trivialmente ordenada. 2. Divide a lista de entrada em duas, chamando o algoritmo recursivamente para ambas. 3. Pega as duas lista, j a ordenadas, e mescla ambas para construir uma lista ordenada a partir das duas. Apresentamos o pseudo-c odigo do Merge Sort: Fun c~ ao Mergesort(Lista A)

14

Lista direita, esquerda Se tamanho(A) = 1 ou tamanho(A) = 0 Retornar A Sen~ ao meio = tamanho(A) / 2 Para x = 1 at e meio Adicionar A[x] a esquerda Para x = meio + 1 at e tamanho(A) Adicionar A[x] a direita esquerda = Mergesort(esquerda) direita = Mergesort(direita) Retornar Merge(esquerda, direita) A fun ca o Merge, ou mescla pode ter diversas implementa c oes, uma das varia c oes mais simples e a seguinte:

Fun c~ ao Merge(A,B) Lista resultado Enquanto tamanho(A) > 0 and tamanho(B) > 0 Se primeiro(A) <= primeiro(B) Adicionar primeiro(A) a resultado A = restante(A) sen~ ao Adicionar primeiro(B) a resultado B = restante(B) Se tamanho(A) > 0 Adicionar restante(A) a resultado Se tamanho(B) > 0 Adicionar restante(B) a resultado Retornar resultado

15

3.2
3.2.1

An alise
Melhor caso

O algoritmo apresentado no pseudo-c odigo como exemplo realiza sempre o mesmo n umero de compara c oes, devido a fun c ao Merge ser apenas uma demonstra c ao simples, entretanto, o Merge Sort no melhor caso e similar ao tempo do Quick Sort com pouco mais de (logn).

3.2.2

Pior caso e caso m edio

Tanto o pior caso quanto o caso m edio do Merge Sort alcan cam um tempo de (nlogn) compara c oes.

16

Heap Sort

4.1

Algoritmo

O heap sort e um algoritmo que utiliza uma heap para fazer a ordena c ao podendo assim ordenar de qualquer forma na retirada do heap. Utiliza uma pequena quantidade de mem oria e e o melhor em ordena c ao generalizada. procedimento heapsort(a[], n:inteiro) var t,i, pai, filho:inteiro; i := n/2; enquanto TRUE fa ca se i > 0 ent~ ao i--; t := a[i]; sen~ ao n--; se n = 0 ent~ ao fim; t := a[n]; a[n] := a[0]; fim_se; pai := i; filho := i*2 + 1; enquanto filho < n fa ca se ((filho + 1 < n) e (a[filho + 1] > a[filho])) ent~ ao

17

filho++; fim_se; se (a[filho] > t) ent~ ao a[pai] := a[filho]; pai := filho; filho := pai*2 + 1; sen~ ao break; fim_se; a[pai] := t; fim_enquanto;

4.2

An alise

A ordena c ao atrav es do heapsort apresenta sempre uma complexidade de O(n log n) ja que e necess ario sempre construir a heap, que para isso usa O(n log n), e deve percorrer o vetor e fazer uma opera c ao de remo c ao da heap, que tamb em custa O(n log n). Ficamos ent ao com a complexidade de O(n log n)1 .

1 lembrando

que O(2*(n log n)) e igual a O(n log n)

18

Count Sort

5.1

Algoritmo

Basicamente, o algoritmo Count Sort determina, para cada elemento de entrada, o n umero de elementos menores que este, e assim, insere o elemento em sua posi c ao j a ordenado, de acordo com [4]. Ou seja, se em um vetor a ser odernado existem 15 elementos, e h a 12 elementos menores que um dado n umero x, ent ao x pertence ` a posi c ao 13. Ele faz isso utilizando outros dois vetores secund arios, B e C, onde B e o vetor ordenado, portanto tem o tamanho igual ` a A o vetor a ser ordenado e C e um vetor auxiliar de tamanho k, onde k e um inteiro qualquer que e pelo menos igual ao maior valor encontrado em A. O pseudo c odigo a seguir e encontrado em [4]: count_sort(A,B,k) para i := 0 at e k faca C[i] := 0 para j := 1 ate comprimento[A] faca C[A[j]] := C[A[j]] + 1 para i := 1 ate k faca C[i] := C[i] + C[i-1] para j := comprimento[A] decremente at e 1 faca B[C[A[j]]] := A[j] C[A[j]] := C[A[j]] -1

19

5.2
5.2.1

An alise
Melhor Caso

A complexidade computacional do Count Sort depende de dois fatores. O primeiro e a quantidade de valores de entrada n, ou seja, o tamanho de A. O segundo, e a faixa em que se encontram os inteiros presentes no vetor a ser ordenado k, tendo assim uma complexidade (n + k). Portando, tem-se uma complexidade O(n), e quanto menor for k, mais pr oximo do melhor caso.

5.2.2

Pior Caso

facil de observar que por k ser um fator que inuencia na complexidade, quanto E maior seu valor, mais pr oximos do pior caso para o Count Sort, portando de complexidade O(n)

5.2.3

Caso M edio

O caso m edio como dito acima, e de complexidade (n), possuindo portanto, um tempo linear para qualquer que seja a entrada.

20

Radix Sort

6.1

Algoritmo

O algoritmo Radix Sort ordena inteiros de acordo com seus d gitos, tratando-os individualmente durante a ordena c ao. Estes inteiros utilizados s ao chamados de chaves, pois podem estar associados a outros tipos de dados. A ordena c ao acontece da seguinte maneira: dados uma certa quantidade de n umeros n, onde estes n umeros s ao compostos por d d gitos, estes s ao ordenados primeiramente pelo d gito menos signicante. Para tal, e utilizado outro m etodo de ordena c ao (normalmente Count Sort) para orden a-los apenas por este d gito. Feito isso, avan ca-se para a pr oxima coluna, e o mesmo procedimento e repetido, por d vezes, at e todos estarem ordenados. Um pseudo c odigo para o Radix Sort encontrado em [4] e mostrado a seguir: radix_sort(A,d) para i := 1 ate d faca ordenar o vetor A no d gito i utilizando um metodo de ordenacao estavel Considerando A o vetor de entrada a ser ordenado e d e o n umero de d gitos dos valores de A.

21

6.2
6.2.1

An alise
Melhor Caso

O melhor caso no algoritmo Radix Sort acontece quando a quantidade de d gitos d e constante e obedece as mesmas condi c oes de melhor caso do Count Sort, e a ordena ca o e feita em tempo linear, com complexidade O(n). Em [4] vemos a prova de tal arma c ao.

6.2.2

Caso M edio

Para o caso m edio, temos que a complexidade do Radix Sort e dada por ((b/r)(n + 2r )), onde n e a quantidade de n umeros, b e a quantidade de d gitos e r e um inteiro positivo qualquer, tal que r b.

22

Bucket Sort

7.1

Algoritmo

Da mesma maneira que o Count Sort, o Bucket Sort e r apido por que recebe alguma informa c ao a respeito da entrada. O Count Sort assume que os valores de entrada se encontram em determinada faixa limitada de inteiros, e o Bucket Sort assume que estes valores s ao gerados por um processo aleat orio que distribui os elementos uniformemente no intervalo [0, 1). O intervalo [0, 1) e dividido em n subintervalos de mesmo tamanho, os buckets, e ent ao os valores de entrada s ao distribu dos entre eles. Agora, dentro dos buckets n ao vazios os valores s ao ordenados, podendo utilizar-se de outro m etodo de ordena c ao, como por exemplo o Insertion Sort. Em seguida, os valores s ao retirados dos buckets em ordem, e a entrada estar a ordenada. Em [4] encontra-se o pseudo c odigo a seguir: bucket_sort(A) n := comprimento[A] para i := 1 at e n fa ca inserir A[i] na lista B[piso(nA[i])] para i := 0 at e n-1 fa ca ordene a lista B[i] com insertion_sort concatene as listas B[0], B[1], ..., B[n-1] em ordem Onde A e o vetor de entrada, B e um vetor de listas e n e a quantidade de elementos.

23

7.2
7.2.1

An alise
Caso M edio

Quando os valores de entrada se encontram em uma distribui c ao uniforme, o algoritmo Bucket Sort tem uma complexidade computacional (n), ou seja, possui um tempo linear. Por em, como provado em [4], este algoritmo e capaz de rodar em tempo linear mesmo em situa c oes onde a entrada n ao se encontra distribuida uniformemente. Ou seja, sua complexidade e da ordem (n).

24

Insertion Sort

8.1

Algoritmo

O insertion sort e muito utilizado por ser um algoritmo simples e ter um bom tempo de execu c ao para pequenas ordena c oes. Uma outra grande vantagem e que ele ordena o vetor in-place portanto n ao utiliza muita mem oria. O algoritmo do insertion sort consiste basicamente em percorrer o vetor da esquerda para a direita e ordenar de acordo com o que se encontra a esquerda da posi c ao atual at e o in cio do vetor. procedimento insere(vetor[],tamanho, valor:inteiro) var i:inteiro; i := tamanho - 1; enquanto i >= 0 e vetor[i] > valor fa ca vetor[i + 1] := vetor[i]; i--; fim_enquanto; vetor[i + 1] := valor; procedimento insertionSort(vetor[], tamanho:inteiro) var i:inteiro; para i de 1 at e tamanho fa ca insere(vetor, i, vetor[i]); fim_para;

25

8.2
8.2.1

An alise
Melhor Caso

O melhor caso no insertion sort ocorre quando o vetor ja est a ordenado pois com isso ele vai correr o vetor e n ao precisar a de nenhuma outra a c ao resultando em um tempo de (n).

8.2.2

Pior Caso

O pior caso no insertion ocorre quando o vetor est a na ordem decrescente pois assim ele ter a que executar uma troca entre todos os elementos do vetor. Todas as trocas ter ao que percorrer o vetor inteiro ocasionando um tempo de (n2 ).

8.2.3

Caso M edio

O m edio caso no insertion sort n ao muda em muito do pior caso e inclusive tem o mesmo tempo de execu c ao: (n2 ).

26

Selection Sort

9.1

Algoritmo

O algoritmo de selection sort e extremamente simples e consiste em encontrar o m nimo valor e trocar este de lugar com a posi c ao atual do programa. programa selectionSort(a[],tamanho:inteiro) var i, j, min: inteiro i := 0; enquanto i < tamanho fa ca min := i; para j de i+1 at e j = tamanho-1 fa ca se a[j] < a[min] min := j; fim_para; i++; troca(a[i], a[min]); fim_enquanto;

9.2

An alise

O selection sort e sempre (n2 ), mesmo se o vetor ja estiver ordenado o algoritmo vai visitar todas as posi c oes por duas vezes.

27

Refer encias Bibliogr acas

[1] mycsresource.net: quicksort. Dispon vel em: <http://www.mycsresource.net/articles/ programming/sorting algos/quicksort/>. Acesso em 14 de agosto de 2007. [2] Introduction to Data Structures - Section 3: Searching and Sorting. Dispon vel em: <http://pages.cs.wisc.edu/ si/CS367/Notes/search-sort.txt>. Acesso em 14 de agosto de 2007. [3] Data Structures. Dispon vel em: <http://www.datastructures.info/>. Acesso em 14 de agosto de 2007. [4] T.H.Cormen, C.E.Leiserson, R.L.Rivest, C.Stein: Introdution to Algorythms, Second Edition, MIT, 2001.

28

APENDICE A -- Implementa c ao do Bubble Sort

Implementa c ao do Bubble Sort em C++. Refer encia: Gary Bronson. A First Book of C++: From Here to There Thomson Learning. #include <iostream.h> int BubbleSort(int [], int); int main() { const int NUMEL = 10; int nums[NUMEL] = {22,5,67,98,45,32,101,99,73,10}; int i, moves; moves = BubbleSort(nums, NUMEL); cout << "The sorted list, in ascending order, is:\n"; for (i = 0; i < NUMEL; ++i) cout << " " <<nums[i]; cout << \n << moves << " were made to sort this list\n";

29

return 0; } int BubbleSort(int num[], int numel) { int i, j, grade, moves = 0; for ( i = 0; i < (numel - 1); i++) { for(j = 1; j < numel; j++) { if (num[j] < num[j-1]) { grade = num[j]; num[j] = num[j-1]; num[j-1] = grade; moves++; } } } return moves; }

30

APENDICE B -- Implementa c ao do Quick Sort

Implementa c ao do Quick Sort em C. #include <iostream> using namespace std; int a[10]; int partition(int left, int right); void swap(int i, int j); void sort(int i, int j); int main() { int i,j=0,k=9; for(i=0;i<10;i++) cin >> a[i]; sort(j,k); for(i=0;i<10;i++) cout << a[i] << endl; } void sort(int left, int right)

31

{ int p; if(left>=right) return; p = partition(left, right); sort(left,p-1); sort(p+1,right); } int partition(int left, int right) { int first=left, pivot=right-; while(left<=right) { while(a[left]<a[pivot]) left++; while((right>=first)&&(a[right]>=a[pivot])) right-; if(left<right) { swap(left,right); left++; } } if(left!=pivot) swap(left,pivot); return left; } void swap(int i, int j)

32

{ int temp=a[i]; a[i]=a[j]; a[j]=temp; }

33

APENDICE C -- Implementa c ao do Merge Sort

Implementa c ao do Merge Sort em C++. #include <iostream> #include <vector> #include <algorithm> #include <iterator> int main(void) { std::vector<unsigned> data; for(unsigned i = 0; i < 10; i++) data.push_back(i); std::random_shuffle(data.begin(), data.end()); std::cout << "Initial: "; std::copy(data.begin(),data.end(),std::ostream_iterator<unsigned>(std::cout," ")); std::cout << std::endl; for(unsigned m = 1; m <= data.size(); m *= 2)

34

{ for(unsigned i = 0; i < data.size() - m; i += m * 2) { std::inplace_merge( data.begin() + i, data.begin() + i + m, data.begin() + std::min<unsigned>(i + m * 2, (unsigned)data.size())); } } std::cout << "Sorted: ";

std::copy(data.begin(),data.end(),std::ostream_iterator<unsigned>(std::cout," ")); std::cout << std::endl; return 0; }