ALGORITMOS E ESTRUTURAS DE DADOS CES-11

(1)

A

LGORITMOS E

A

LGORITMOS E

E

STRUTURAS DE

D

ADOS

CES-11

Prof. Paulo André Castro

[email protected]

Sala 110 – Prédio da Computação www.comp.ita.br/~pauloac

(2)

C

AP

. 5. T

ÉCNICAS DE

O

RDENAÇÃO

5.1. Introdução

5.2. Métodos simples de ordenação

5.3. O método Shell-Sort

5.4. O método Quick-Sort

(3)

5.1 – I

NTRODUÇÃO

Ordenação é uma atividade importantíssima em

processamento automático de informações.

Que tal procurar

−

Um nome numa lista telefônica

−

Um nome numa lista de contas bancárias

−

Uma palavra em um dicionário lingüístico

se as relações não estiverem em ordem alfabética?

(4)

O processo de ordenação se aplica a um conjunto de objetos

em que se possa verificar entre eles a relação ≤

≤≤

≤ (menor ou igual), ou ≥ (maior ou igual).

Os conjuntos mais comuns são vetores de

−

Números

−

Números

−

Nomes ou cadeias de caracteres em geral

(5)

Vetores de estruturas também podem ser ordenados

Exemplo: relação com diversas informações sobre os

funcionários de uma empresa:

(6)

Este vetor pode ser ordenado por qualquer campo dessas

estruturas:

Ordem alfabética dos nomes ou dos

−

Ordem alfabética dos nomes ou dos

setores

−

Ordem crescente ou decrescente de

salários ou de idade

O campo de um vetor de estruturas usado para ordená-lo é

(7)

Existem vários algoritmos para fazer ordenação de vetores:

−

Alguns mais simples, porém ineficientes

−

Outros mais eficientes, porém mais

complexos

Alguns critérios para julgar a eficiência dos algoritmos de

ordenação: ordenação:

−

Número de comparações de chaves

−

Número de movimentações de elementos

(8)

O tempo de comparação depende da chave usada:

− Para números, basta um dos operadores ≤≤≤≤ ou ≥≥≥≥;

− Para cadeias de caracteres, usa-se funções para compará-las;

exemplo: strcmp da linguagem C

Há casos de chaves múltiplas, como a ordenação por idade,

sendo dada a data de nascimento:

− Compara-se primeiramente o ano, depois o mês e finalmente o dia − Nestes casos, a comparação é mais complexa e pode ser

conveniente um subprograma específico

(9)

O tempo de movimentação depende do tipo e tamanho

dos elementos do vetor a ser ordenado:

−

Para números, a movimentação é

pequena

−

Para grandes estruturas, há grande

−

Para grandes estruturas, há grande

movimentação de dados

(10)

No caso de grandes estruturas, usa-se um vetor de

ponteiros, cada um para uma estrutura do vetor

Nome Data de Nascimento Setor Salário Dia Mês Ano Gilberto 03 05 1980 Almox 850 Antonio 05 12 1970 Admin 2300 Pont 1 2 10 Pedro 23 07 1975 Fabric 1050 Augusto 05 10 1960 Diret 8000 Claudio 07 03 1984 Ferr. 1850 Marcos 17 11 1976 Recep 850 Nilton 20 01 1982 Proj 2300 Vicente 15 08 1979 Contr 2000 3 4 5 6 7 8

(11)

Para a ordenação basta alterar os apontamentos,

evitando-se a movimentação dessas estruturas

Nome Data de Nascimento Setor Salário

Dia Mês Ano Gilberto 03 05 1980 Almox 850 Antonio 05 12 1970 Admin 2300 Pont 1 2 11 Antonio 05 12 1970 Admin 2300 Pedro 23 07 1975 Fabric 1050 Augusto 05 10 1960 Diret 8000 Claudio 07 03 1984 Ferram. 1850 Marcos 17 11 1976 Recep 850 Nilton 20 01 1982 Proj 2300 Vicente 15 08 1979 Contr 2000 3 4 5 6 7 8

(12)

No restante deste capítulo, para maior simplicidade, os

algoritmos irão atuar sobre vetores de inteiros.

A seguinte declaração será usada por esses algoritmos:

typedef int vetor [nmax]

(nmax é o número máximo de elementos dos

vetores)

Para vetores de outros tipos, basta alterar as

comparações e os movimentos de elementos.

São apresentados a seguir três métodos simples de

ordenação e, depois, quatro outros mais eficientes.

(13)

5.2 – M

ÉTODOS

S

IMPLES DE

O

RDENAÇÃO

Tais métodos são considerados lentos 0(n2) no pior caso e no

caso médio)

São usados para ordenar vetores pequenos

São apresentados aqui três desses métodos:

−

Bubble-Sort

−

Insertion-Sort

−

Selection-Sort

(14)

5.2.1 – Bubble-Sort

O método consiste em:

− Percorrer o vetor várias vezes

− Durante cada percurso, efetuar troca de posição de elementos

adjacentes, caso o elemento da esquerda seja maior que o da direita

− Se, durante um dos percursos, não houver trocas, considera-se que o

vetor está ordenado

− Em cada percurso, um elemento atinge sua posição definitiva

(15)

Exemplo: seja o vetor abaixo e o método em seu início

16 45 72 5 8 67 95 74 70 80

0 1 2 3 4 5 6 7 8 9

p

(cursor para percorrer o vetor várias vezes)

(limitante de i a cada percurso) i

V

15 cada percurso) trocou (semáforo que acende quando há troca)

(16)

Não trocar 16 45 72 5 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

16 trocou

(17)

Não trocar 16 45 72 5 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

17 trocou

(18)

Trocar 16 45 72 5 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

18 trocou

(19)

Trocar 16 45 5 72 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

19 trocou

(20)

Trocar 16 45 5 8 72 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

20 trocou

(21)

Não trocar 16 45 5 8 67 72 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

21 trocou

(22)

Trocar 16 45 5 8 67 72 95 74 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

22 trocou

(23)

Trocar 16 45 5 8 67 72 74 95 70 80 0 1 2 3 4 5 6 7 8 9 p i

V

23 trocou

(24)

Trocar 16 45 5 8 67 72 74 70 95 80 0 1 2 3 4 5 6 7 8 9 p i

V

24 trocou

(25)

95 em sua posição definitiva

trocou acesa: começar novo percurso retroceder p 16 45 5 8 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

25 trocou

(26)

Não trocar 16 45 5 8 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 26 p trocou

(27)

Trocar 16 45 5 8 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 27 p trocou

(28)

Trocar 16 5 45 8 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 28 p trocou

(29)

Não trocar 16 5 8 45 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 29 p trocou

(30)

Não trocar 16 5 8 45 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 30 p trocou

(31)

Não trocar 16 5 8 45 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 31 p trocou

(32)

Trocar 16 5 8 45 67 72 74 70 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 32 p trocou

(33)

Não trocar 16 5 8 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 33 p trocou

(34)

trocou acesa: iniciar novo percurso 16 5 8 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

34 p trocou

(35)

Trocar 16 5 8 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 35 p trocou

(36)

Trocar 5 16 8 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 36 p trocou

(37)

Não trocar 5 8 16 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 37 p trocou

(38)

Não trocar 5 8 16 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 38 p trocou

(39)

Não trocar 5 8 16 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 39 p trocou

(40)

Trocar 5 8 16 45 67 72 70 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 40 p trocou

(41)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 41 p trocou

(42)

trocou acesa: novo percurso 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

42 p trocou

(43)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 43 p trocou

(44)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 44 p trocou

(45)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 45 p trocou

(46)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 46 p trocou

(47)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 47 p trocou

(48)

Não trocar 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9 p

V

i 48 p trocou

(49)

trocou apagada: vetor ordenado 5 8 16 45 67 70 72 74 80 95 0 1 2 3 4 5 6 7 8 9

V

49 trocou

(50)

A função BubbleSort:

void BubbleSort (int n, vetor V) { int i, p;

logic trocou;

for (p = n-2, trocou = TRUE; p >= 0 && trocou; p--) for (trocou = FALSE, i = 0; i <= p; i++)

if (V[i] > V[i+1]) {

Trocar (&V[i], &V[i+1]); Trocar (&V[i], &V[i+1]); trocou = TRUE;

} }

void Trocar (int *x, int *y) { int temp;

temp = *x; *x = *y; *y = temp; }

50

A cada vez que a condição do if se verificar, haverá movimentação de 3

(51)

5.2.2 – Insertion-Sort

O método considera o vetor sempre dividido em duas partes:

a parte ordenada, do lado esquerdo, e a parte desordenada, do lado direito.

Inicialmente, a parte ordenada contém apenas V[0]; depois,

cada elemento da parte desordenada é inserido na parte ordenada, mantendo a ordenação

ordenada, mantendo a ordenação

A cada elemento a ser inserido, percorre-se a parte ordenada

até encontrar a posição correta para inserção.

(52)

Exemplo: seja o vetor abaixo e o método no início da inserção de um elemento genérico

5 16 45 72 8 67 95 74 70 80

0 1 2 3 4 5 6 7 8 9

j

(cursor para o elemento a ser inserido)

(cursor para percorrer a parte ordenada) i

V

52 j a parte ordenada) 8 aux aux = V[i]

(53)

aux < V[j]: V[j+1] recebe V[j]; retroceder j 5 16 45 72 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 j i

V

53 j 8 aux aux = V[i]

(54)

V

(55)

V

(56)

aux >= V[j]: V[j+1] recebe aux; avançar a parte ordenada 5 16 16 45 72 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 j i

V

(57)

5 8 16 45 72 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 i

V

57 8 aux aux = V[i]

Parte ordenada Parte desordenada

O mesmo se repete até que tudo fique ordenado

(58)

A função InsertionSort:

void InsertionSort (int n, vetor V) { int i, j, aux;

int achou;

for (i = 1; i < n; i++) { aux = V[i];

achou = FALSE; j = i-1; while (j >= 0 && !achou) while (j >= 0 && !achou)

if (aux < V[j]) {

V[j+1] = V[j]; j--;

}

else achou = TRUE; if (j+1 != i)

V[j+1] = aux; }

}

58

A cada vez que a condição do if se verificar, haverá movimentação de 1

elemento

Antes e depois do while mais uma

(59)

5.2.3 – Selection-Sort

O método consiste em percorrer o vetor várias vezes

Durante cada percurso, seleciona o menor elemento,

colocando-o em sua posição definitiva.

(60)

Exemplo: seja o vetor abaixo e o método em seu início

16 45 72 5 8 67 95 74 70 80

0 1 2 3 4 5 6 7 8 9

j

(cursor na posição de colocação do menor elemento do percurso)

(cursor para percorrer o vetor várias vezes, para encontrar o menor elemento do percurso)

i

V

60

j

encontrar o menor elemento do percurso)

indmin

(destinado a guardar o índice do menor elemento de um percurso)

(61)

Após o 1º percurso:

indmin ≠≠≠≠ i: trocar V[i] com V[indmin]

16 45 72 5 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 i

V

61 3 indmin _{Avançar i}

(62)

5 45 72 16 8 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 i

V

(63)

5 8 72 16 45 67 95 74 70 80 0 1 2 3 4 5 6 7 8 9 i

V

(64)

5 8 16 72 45 67 95 74 70 80

0 1 2 3 4 5 6 7 8 9

i

V

64

indmin _{E assim por diante,}

até que o vetor fique ordenado

(65)

A função SelectionSort:

void SelectionSort (int n, vetor V) { int i, j, indmin; for (i = 0; i < n-1; i++) { indmin = i; for (j = i+1; j <= n-1; j++) if (V[j] < V[indmin]) indmin = j; indmin = j; if (indmin != i)

Trocar (&V[i], &V[indmin]); }

}

65

Só ocorre movimentação de elementos quando o índice do menor for encontrado

(66)

5.3 – O M

ÉTODO

S

HELL

-S

ORT

O método Shell-Sort é uma generalização do

Insertion-Sort.

No Insertion-Sort, a maioria dos deslocamentos de

elementos é de apenas uma casa.

Se o menor elemento estiver no final do vetor, são

necessários n deslocamentos para colocá-lo ordenadamente.

Shell-Sort faz movimentos de passos maiores

(67)

O vetor V pode ser assim visualizado: 0 1 2 3 . . . h-1 h h+1 h+2 h+3 . . . 2h-1 2h 2h+1 2h+2 2h+3 3h-1 3h 3h+1 3h+2 3h+1 . . n-1 V O valor de h < n é empírico 67 V

(68)

Pode-se dividir V em h sub-vetores intercalados: 0 1 2 3 . . . h-1 h h+1 h+2 h+3 . . . 2h-1 2h 2h+1 2h+2 2h+3 3h-1 3h 3h+1 3h+2 3h+1 . . n-1 V 0 h 2h 3h 1 h+1 2h+1 3h+1 68 2 h+2 2h+2 3h+2 3 h+3 2h+3 3h+3 h-1 2h-1 3h-1

(69)

O valor de h é inicialmente grande, mas vai caindo

até 1

Para cada valor de h, ordena-se cada um desses

sub-vetores pelo Insertion-Sort

0 h 2h 3h 1 h+1 2h+1 3h+1 69 2 h+2 2h+2 3h+2 3 h+3 2h+3 3h+3 h-1 2h-1 3h-1

(70)

Quando h = 1, tem-se o Insertion-Sort original:

− Então boa porção do vetor já estará ordenada pelos passos

anteriores (maiores valores de h)

(71)

O valor inicial de h e a razão de seu decréscimo é

escolhida empiricamente; para cada escolha, um

comportamento diferente.

(72)

O algoritmo a seguir escolhe a seguinte seqüência de valores

de h, que tem dado bons valores de desempenho: . . . , 1093, 364, 121, 40, 13, 4, 1 O valor inicial é obtido pela fórmula

h(novo) = 3*h(antigo) + 1 até encontrar o maior valor de h < n

Os valores seguintes de h são obtidos pela fórmula

h(novo) = h(antigo) / 3

72

(73)

void ShellSort (int n, vetor V) { int i, j, h, aux; int achou;

h = 1;

do h = 3*h + 1; while (h < n); do {

h = h/3;

for (i = h; i <= n-1; i++) {

aux = V[i]; j = i; achou = FALSE;

Insertion-Sort de passo h, intercalado

while (!achou && j >= h) if (aux < V[j-h]) {

V[j] = V[j-h]; j = j - h; }

else achou = TRUE; if (j != i) V[j] = aux; }

} while (h > 1); }

(74)

Comparação entre o número de movimentos de

elementos no Insertion-Sort e Shell-Sort, usando

vetor de caracteres:

a) Insertion-Sort:

A 0 S 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 74 A S O R T I N G E X A M P L E 1 no _movtos 1 no _acumulado movtos aux Sempre há um movimento para aux

(75)

a) Insertion-Sort:

A 0 S 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 75 A S O R T I N G E X A M P L E 3 no _movtos 4 no _acumulado movtos aux O -> aux; S -> 2 aux -> 1

(76)

a) Insertion-Sort:

A 0 O 1 S 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 76 A O S R T I N G E X A M P L E 3 no _movtos 7 no _acumulado movtos aux R -> aux; S -> 3 aux -> 2

(77)

a) Insertion-Sort:

A 0 O 1 R 2 S 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 77 A O R S T I N G E X A M P L E 1 no _movtos 8 no _acumulado movtos aux T -> aux;

(78)

a) Insertion-Sort:

A 0 O 1 R 2 S 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 78 A O R S T I N G E X A M P L E 6 no _movtos 14 no _acumulado movtos aux

(79)

a) Insertion-Sort:

A 0 I 1 O 2 R 3 S 4 T 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 79 A I O R S T N G E X A M P L E 6 no _movtos 20 no _acumulado movtos aux

(80)

a) Insertion-Sort:

A 0 I 1 N 2 O 3 R 4 S 5 T 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 80 A I N O R S T G E X A M P L E 8 no _movtos 28 no _acumulado movtos aux

(81)

a) Insertion-Sort:

A 0 G 1 I 2 N 3 O 4 R 5 S 6 T 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 81 A G I N O R S T E X A M P L E 9 no _movtos 37 no _acumulado movtos aux

(82)

a) Insertion-Sort:

A 0 E 1 G 2 I 3 N 4 O 5 R 6 S 7 T 8 X 9 A 10 M 11 P 12 L 13 E 14 82 A E G I N O R S T X A M P L E 1 no _movtos 38 no _acumulado movtos aux

(83)

a) Insertion-Sort:

A 0 E 1 G 2 I 3 N 4 O 5 R 6 S 7 T 8 X 9 A 10 M 11 P 12 L 13 E 14 83 A E G I N O R S T X A M P L E 11 no _movtos 49 no _acumulado movtos aux

(84)

a) Insertion-Sort:

A 0 A 1 E 2 G 3 I 4 N 5 O 6 R 7 S 8 T 9 X 10 M 11 P 12 L 13 E 14 84 A A E G I N O R S T X M P L E 8 no _movtos 57 no _acumulado movtos aux

(85)

a) Insertion-Sort:

A 0 A 1 E 2 G 3 I 4 M 5 N 6 O 7 R 8 S 9 T 10 X 11 P 12 L 13 E 14 85 A A E G I M N O R S T X P L E 6 no _movtos 63 no _acumulado movtos aux

(86)

a) Insertion-Sort:

A 0 A 1 E 2 G 3 I 4 M 5 N 6 O 7 P 8 R 9 S 10 T 11 X 12 L 13 E 14 86 A A E G I M N O P R S T X L E 10 no _movtos 73 no _acumulado movtos aux

(87)

a) Insertion-Sort:

A 0 A 1 E 2 G 3 I 4 L 5 M 6 N 7 O 8 P 9 R 10 S 11 T 12 X 13 E 14 87 A A E G I L M N O P R S T X E 13 no _movtos 86 no _acumulado movtos aux

(88)

a) Insertion-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 L 6 M 7 N 8 O 9 P 10 R 11 S 12 T 13 X 14 88 A A E E G I L M N O P R S T X no _movtos 86 no _acumulado movtos aux

(89)

b) Shell-Sort:

A 0 S 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 Ordenação para h = 13 89 1 no _movtos aux A S O R T I N G E X A M P L E no _{acumulado de movtos} h = 13 h = 4 h = 1 total 1 1

(90)

b) Shell-Sort:

A 0 S 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 E 14 Ordenação para h = 13 90 3 no _movtos aux A S O R T I N G E X A M P L E no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 4

(91)

b) Shell-Sort:

A 0 E 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 S 14 Fim da ordenação para h = 13

91 3 no _movtos aux A E O R T I N G E X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 4

(92)

b) Shell-Sort:

A 0 E 1 O 2 R 3 T 4 I 5 N 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 92 1 no _movtos aux A E O R T I N G E X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 1 5

(93)

b) Shell-Sort:

(94)

b) Shell-Sort:

(95)

b) Shell-Sort:

A 0 E 1 N 2 R 3 T 4 I 5 O 6 G 7 E 8 X 9 A 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 95 3 no _movtos aux A E N R T I O G E X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 8 12

(96)

b) Shell-Sort:

A 0 E 1 N 2 G 3 T 4 I 5 O 6 R 7 E 8 X 9 A 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 96 3 no _movtos aux A E N G T I O R E X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 11 15

(97)

b) Shell-Sort:

A 0 E 1 N 2 G 3 E 4 I 5 O 6 R 7 T 8 X 9 A 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 97 1 no _movtos aux A E N G E I O R T X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 12 16

(98)

b) Shell-Sort:

A 0 E 1 N 2 G 3 E 4 I 5 O 6 R 7 T 8 X 9 A 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 98 4 no _movtos aux A E N G E I O R T X A M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 16 20

(99)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 R 7 T 8 X 9 O 10 M 11 P 12 L 13 S 14 Ordenação para h = 4 99 3 no _movtos aux A E A G E I N R T X O M P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 19 23

(100)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 T 8 X 9 O 10 R 11 P 12 L 13 S 14 Ordenação para h = 4 100 3 no _movtos aux A E A G E I N M T X O R P L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 22 26

(101)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 P 8 X 9 O 10 R 11 T 12 L 13 S 14 Ordenação para h = 4 101 3 no _movtos aux A E A G E I N M P X O R T L S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 25 29

(102)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 4 102 1 no _movtos aux A E A G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 30

(103)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Fim da ordenação para h = 4

103 no _movtos aux A E A G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 30

(104)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

104 1 no _movtos aux A E A G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 1 31

(105)

b) Shell-Sort:

A 0 E 1 A 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

105 3 no _movtos aux A E A G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 4 34

(106)

b) Shell-Sort:

A 0 A 1 E 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

106 1 no _movtos aux A A E G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 5 35

(107)

b) Shell-Sort:

A 0 A 1 E 2 G 3 E 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

107 3 no _movtos aux A A E G E I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 8 38

(108)

b) Shell-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 N 6 M 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

108 5 no _movtos aux A A E E G I N M P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 13 43

(109)

b) Shell-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 M 6 N 7 P 8 L 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

109 6 no _movtos aux A A E E G I M N P L O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 19 49

(110)

b) Shell-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 L 6 M 7 N 8 P 9 O 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

110 3 no _movtos aux A A E E G I L M N P O R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 22 52

(111)

b) Shell-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 L 6 M 7 N 8 O 9 P 10 R 11 T 12 X 13 S 14 Ordenação para h = 1 (Insertion-Sort)

111 7 no _movtos aux A A E E G I L M N O P R T X S no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 29 59

(112)

b) Shell-Sort:

A 0 A 1 E 2 E 3 G 4 I 5 L 6 M 7 N 8 O 9 P 10 R 11 S 12 T 13 X 14 Fim da ordenação para h = 1 (Insertion-Sort)

112 no _movtos aux A A E E G I L M N O P R S T X no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 29 59

(113)

Insertion-Sort: Shell-Sort:

No Shell-Sort, o número de movimentos para h = 1 é

29

no _{acumulado de movtos} h = 13 h = 4 h = 1 total 4 26 29 59 86 no _acumulado de movtos

29 (86-29=57) 57 movimentos do Insertion-Sort foram

compensados com (59-29=30) 30 movimentos do

Shell-Sort com h > 1.

(114)

Observações:

Para vetor inicialmente já ordenado, Shell-Sort é pior que

Insertion-Sort, devido ao número de comparações

Outros métodos simples de ordenação poderiam ser usados

para cada valor de h, mas o mais usado é o Insertion-Sort.

Há quem use um método para e outro para

Há quem use um método para h > 1 e outro para h = 1

(115)

Observações:

Referências bibliográficas indicam que o algoritmo anterior é

O(n (log n)2_{) e também O(n}1.5_).

Donald Knuth prova que, mesmo usando apenas 2 valores

de h, a saber,

(16 n / )1/3 _{e 1}

O método resultante é O(n5/3_{), o que é melhor que o pior caso}

do Insertion-Sort, que é O(n2_).

O tempo de execução do algoritmo apresentado não é muito

sensível ao estado inicial do vetor, ao contrário do

Insertion-Sort que é O(n) para vetor já ordenado e O(n2₎