Algoritmos de Ordenacao

AULA #3

DR. TICONGOLO, INACIO GASPAR

___________________________________________________________________
Março de 2021
1. Algoritmos de Ordenação
>> BubbleSort
>> SelectionSort
>> InsertSort
 Recursividade
Recursão/Recursividade é caracterizada por auto
chamada no corpo de um algoritmo, i.é., um
método chama-se a si mesmo.

A recursão é utilizada quando na resolucao dum

problema, aparece outro problema do mesmo tipo
com o principal. Entao, invocamos a solução do
problema principal para resolver o novo problema.
3
 Recursividade (cont.)
A chamada de um método para ele mesmo, é igual
a chamada de qualquer outro método. Exemplo de
método recursivo que calcula o fatorial n!.

4
 Recursividade (cont.)
Exemplo:

public int factorial (int x)

{
if (x= =0)
return 1;
return x*factorial(x-1);
}
5
 Bubble Sort
O bubble sort, ou ordenação por flutuação -
algoritmo de ordenação dos mais simples.

Percorremos o vector diversas vezes, a cada

passagem fazendo flutuar para o topo o maior
elemento da sequência (lembra-nos como as
bolhas em um tanque de água procuram seu
próprio nível, daí o nome do algoritmo).

6
7
Implementação (bubblesort)
 
public static void bubbleSort(int[]a) {
for (int i = 0, k=1; i < a.length-1; i++, k++) {
for (int j = 0; j < a.length-k; j++) {
if (a[j] > a[j+1]) {
swap(a, j, j+1);
}
System.out.println(a);
}

}
}

8
 Selection sort
O selection sort (ordenação por seleção) -
ordenação baseada em passar sempre o menor
valor do vetor para a primeira posição (ou o
maior dependendo da ordem requerida),

depois o de segundo menor valor para a segunda

posição, e assim é feito sucessivamente com os
(n-1) elementos restantes, até os últimos dois
elementos.
9
10
Implementação
public static void selectionSort(int[] a) {
int index_min;
for (int i=0; i<a.length; i++) {
index_min = i;
for (int j=i+1; j<a.length; j++) {
if (a[j]<a[index_min]) {
index_min=j;
}
}
if(index_min != i)
{
swap(a, index_min, i);
System.out.println(a);
}
}} 11
private static void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}

12
 Insertion Sort
Insertion sort, ou ordenação por inserção, é um
simples algoritmo de ordenação, eficiente quando
aplicado a um pequeno número de elementos.

Percorre um vector de elementos da esquerda para a

direita e à medida que avança vai deixando os
elementos mais à esquerda ordenados.

13
14
Implementação
public static void insertionSort(int[] a)
{
for (int i = 0; i < a.length; i++)
{
int copyNumber = a[i];
int j = i;
while (j > 0 && copyNumber < a[j-1])
{
a[j] = a[j-1];
j--;
System.out.println(a);

}
a[j] = copyNumber;
System.out.println(a);

}
System.out.println(a);
}
15
Pesquisas
 Pesquisa Sequencial

public static int buscaSequencial(int a[], int valor)

{
for (int i=0; i< a.length; i++)
{
if(a[i]= =valor)
return i;
}
return -1;
}
17
 Pesquisa Binária

A pesquisa ou busca binária (em inglês binary search

algorithm ou binary chop) - pressupõe que o array
está ordenado e realiza sucessivas divisões do espaço
de busca (divisão e conquista) comparando o
elemento buscado (chave) com o elemento no meio
do array. Se o elemento do meio do array for a chave,
a busca termina com sucesso. Caso contrário, se o
elemento do meio vier antes do elemento buscado,
então a busca continua na metade posterior do array.
E finalmente, se o elemento do meio vier depois da
chave, a busca continua na metade anterior do array.
18
 Exemplo:
• Vamos imaginar um array de 7 elementos,
sendo a[ 1,2,3,4,5,6,7], o dado a ser
• procurado é ‘7’, o índice de início é 0 e o índice
final é 6, então ao entrar na função:

19
( )

( )

( )

20
 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

2 5 10 12 15 20 28 29 30 40 43 45 60 70 79

Indices Indices Indices

Inicio=0 Indices Indices
Inicio=7+1=8 Inicio=8
Fim=14 Inicio=9+1=10 Inicio=10
Fim=14 Fim=10
Meio=7 Fim=10 Fim=10-1=9
Meio=11 Meio=9
Meio=10 Meio=10

42

21
O dado de índice meio é o dado procurado
então a função retorna meio = 6 (o índice
do dado procurado).

22
1. Merge sort
I33
2. Heapsort (2,3)
1. Quick sort
3. Shell sort (4,5)
2. Merge sort
4. Radix sort (6)
3. Heapsort
• Gnome sort
4. Shell sort
5. Counting sort (7)
5. Cocktail sort
• Bucket sort
6. Radix sort
6. Cocktail sort (8,9)
• Gnome sort
7. Timsort (10)
8,9 Quick sort (11,12)
23