Analise e Desenvolvimento de

Sistemas
Classificação do
Método de Shell
Aluno: Hugo, Ruan, Natan,
Pablo, Gustavo Barbosa
Professora: Luiz Ricardo
Begosso
Hoje falaremos sobre o
Método de Shell
Mas o que são algoritmos
de ordenação
É um conjunto de instruções que rearranjam os elementos de uma
lista ou array em uma ordem específica (ex: numérica ou
lexicográfica, crescente ou decrescente).

Com o propósito de tornar os dados mais eficientes para busca,

análise e processamento (ex: organizar resultados em um banco de
dados).
 Qual a importância
na computação
Otimização de Buscas: Permite o uso da Pesquisa Binária (acesso mais rápido a
dados).
Eficiência de Processamento: Fundamental para o funcionamento e desempenho
de muitos outros algoritmos.
Organização/Usabilidade: Essencial em bancos de dados e interfaces de usuário
(ex: ordenar resultados por preço).

Exemplo
Simples (Mais lentos): Bubble Sort, Selection Sort, Insertion Sort.
Eficientes (Mais rápidos): Quick Sort, Merge Sort, Heap Sort.
Origem do
Método de Shell
Professor: Luiz Ricardo
Begosso
Quem criou ?
O algoritmo Shell Sort foi criado
por Donald Shell em 1959.
Curiosidade
Ele o publicou enquanto estava na
Universidade de Cincinnati. O
método é notável por ser um dos
primeiros algoritmos de ordenação
a superar a barreira da
complexidade de algoritmos
simples como o Insertion Sort.
 Primeiro algoritmo de
ordenação com melhoria
sobre o Insertion Sort
O Shell Sort é reconhecido como o primeiro algoritmo de ordenação publicado cuja
complexidade de tempo era melhor do que — ou seja, uma melhoria
significativa sobre o Insertion Sort e outros métodos simples da época (Bubble Sort,
Selection Sort).
Essa melhoria de desempenho foi alcançada justamente pela sua inovação em
permitir a troca de elementos distantes, que o Insertion Sort não conseguia fazer.
 Ideia Principal
A ideia principal do Método de Shell é aplicar uma versão do Insertion Sort em elementos que estão
distantes no array, e não apenas adjacentes.
"Quebrar" a Ineficiência do Insertion Sort: O Insertion Sort é muito lento quando precisa mover um
elemento de uma ponta à outra da lista, pois só pode fazer trocas de um em um.

Permitir Grandes Saltos: O Shell Sort resolve isso definindo um intervalo que permite a troca
rápida de elementos muito distantes. Isso move os itens mais desordenados para perto de suas
posições corretas em poucas passadas.

Convergir para o Ordenamento Final: O intervalo é progressivamente reduzido. A cada redução, a

lista fica cada vez mais ordenada, até que a última passada se comporta como um Insertion
Sort padrão, mas em um array que já está quase perfeitamente organizado, garantindo a ordenação
completa de forma muito mais rápida.

Em suma: O Shell Sort é um Insertion Sort aperfeiçoado que faz "grandes trocas" no início para diminuir o
trabalho nas etapas finais.
Exemplo
O Shell Sort começa com
"grandes saltos" para organizar
elementos distantes e
gradualmente diminui o gap para
realizar um ajuste fino e
completar a ordenação de forma
eficiente.
Teste de Mesa
Entendendo o método
 Explicação
public static void shellSort(int[] v) { Entra na função passando o vetor
int n = [Link];
inteiro para aplicar o método.
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = v[i];
int j; Valores
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
} Índice
}
}
 Explicação
public static void shellSort(int[] v) { Conta quantos elementos esse
int n = [Link];
vetor tem!
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = v[i];
int j; n=8
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) { Entra na estrutura de repetição e
int n = [Link];
aplica as condições.
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) { Entra em mais uma estrutura de
int n = [Link];
repetição.
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 0 0
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 1 4

v[ i ] v[ j ] v[ j - gap ]

1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 0 0
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 1 4

v[ i ] v[ j ] v[ j - gap ]

1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 0
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 1 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 4 1 4

v[ i ] v[ j ] v[ j - gap ]

1 2
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 1
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 4 1 4

v[ i ] v[ j ] v[ j - gap ]

2 2 2
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 1
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 2 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 0 1 4

v[ i ] v[ j ] v[ j - gap ]

2 2
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 0 1 4

v[ i ] v[ j ] v[ j - gap ]

2 1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 4

v[ i ] v[ j ] v[ j - gap ]

6
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 6 4

v[ i ] v[ j ] v[ j - gap ]

6
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 1 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 6 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 2 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 5 6 4

v[ i ] v[ j ] v[ j - gap ]

4
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 2 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 5 6 4

v[ i ] v[ j ] v[ j - gap ]

6 4
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 2 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 6 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 2 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 6 7 4

v[ i ] v[ j ] v[ j - gap ]

7
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 2 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 6 7 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 3 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 6 6 7 4

v[ i ] v[ j ] v[ j - gap ]

5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 3 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 6 6 7 4

v[ i ] v[ j ] v[ j - gap ]

7 5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 3 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 3 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 3 4

v[ i ] v[ j ] v[ j - gap ]

3
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 3 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 3 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 2
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 3
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 7 3 4

v[ i ] v[ j ] v[ j - gap ]

8
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 3
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 7 3 4

v[ i ] v[ j ] v[ j - gap ]

8 8
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 3
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 8 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 3 3 4

v[ i ] v[ j ] v[ j - gap ]

8
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 7 3 3 4

v[ i ] v[ j ] v[ j - gap ]

3
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 8 4

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2 5 2

v[ i ] v[ j ] v[ j - gap ]

5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 4 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2 5 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 5 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2 2 5 2

v[ i ] v[ j ] v[ j - gap ]

1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 5 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 2 2 5 2

v[ i ] v[ j ] v[ j - gap ]

5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 5 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 5 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 3 2

v[ i ] v[ j ] v[ j - gap ]

3
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 5 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 3 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 4
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 3 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 3 3 2

v[ i ] v[ j ] v[ j - gap ]

4
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 5
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 3 3 2

v[ i ] v[ j ] v[ j - gap ]

4 4
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 5
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 4 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 1 3 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 6
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 3 1 3 2

v[ i ] v[ j ] v[ j - gap ]

3
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 6
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 6
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 2 2

v[ i ] v[ j ] v[ j - gap ]

2
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 6 6
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 2 2

v[ i ] v[ j ] v[ j - gap ]
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 7 6
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 2 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 4 2 2

v[ i ] v[ j ] v[ j - gap ]

5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 7 7
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 5 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 4 2 2

v[ i ] v[ j ] v[ j - gap ]

5 5
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 8 7
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 5 4 5 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 2 2 2

v[ i ] v[ j ] v[ j - gap ]

5 1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 8 8
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 2 4 5 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 4 2 2 2

v[ i ] v[ j ] v[ j - gap ]

2 1
 Explicação
public static void shellSort(int[] v) {
int n = [Link];
Comparações Trocas
for (int gap = n / 2; gap > 0; gap /= 2) { 8 8
for (int i = gap; i < n; i++) {
int temp = v[i];
int j;
for (j = i; j >= gap && v[j - gap] > temp; j -= gap) {
v[j] = v[j - gap]; 1 3 2 4 5 6 7 8
} 0 1 2 3 4 5 6 7
v[j] = temp;
}
} n i j temp gap
}
8 5 2

v[ i ] v[ j ] v[ j - gap ]