Estrutura de Dados - Professor Salustiano Rodrigues

Estrutura de Dados
Busca e Ordenação
Prof. Salustiano Rodrigues de Oliveira
[email protected]
www.profsalu.com.br
Ordenação
• Nas aulas anteriores vimos como trabalhar com dados passados
pelo usuário, normalmente o usuário que vai fornecer essas
informações não está preocupado em passar esses dados de uma
forma ordenada, deixando a cargo do sistema a ordenação e
organização.
• Muitas vezes necessitamos que esses dados apresentem uma
ordem para que possamos realizar ações como verificar se
determinado cliente pagou uma conta, se uma pessoa consta em
uma lista de cliente, se um determinado número faz parte de uma
agenda telefônica e assim por diante.
Ordenação
• Em virtude das várias aplicações, foram desenvolvidos
diversos algoritmos de ordenação que consistem,
basicamente, em realizar comparações sucessivas e
trocar os elementos de posição, os quais, muitas
vezes, estão relacionados ou trabalham em conjunto
com algoritmos de busca, destinados a localizar
determinado elemento de forma mais eficiente.
Ordenação por seleção
• O método de ordenação por seleção é considerado um
dos mais simples e constitui-se na execução dos
seguintes passos:
1. Selecione o menor elemento da sequencia
2. Troque-o com o que está na primeira posição
3. Repita as operações anteriores para os demais
elementos, até que reste apenas um.
Ordenação por seleção
• Exemplo de ordenação por seleção:
Posição
0
1
2
3
4
5
6
7
Valores Iniciais
23
4
33
45
19
12
28
40
Iteração 1
4
23
33
45
19
12
28
40
Iteração 2
4
12
33
45
19
23
28
40
Iteração 3
4
12
19
45
33
23
28
40
Iteração 4
4
12
19
23
33
45
28
40
Iteração 5
4
12
19
23
28
45
33
40
Iteração 6
4
12
19
23
28
33
45
40
Iteração 7
4
12
19
23
28
33
40
45
Ordenação por seleção em Java
public static void main(String[] args) {
int num[] = {23, 4, 33, 45, 19, 12, 28, 40};//DECLARAÇÃO DO VETOR
int menor, x;
//DECLARAÇÃO DAS VARIÁVEIS DE APOIO
for (int i = 0; i < num.length -1; i++) {
menor = i;
//GUARDA A POSIÇÃO DO MENOR VALOR
x = num[i];
//ARMAZENA O MENOR VALOR
for (int j = i + 1; j < num.length; j++) {
if(num[j] < x){
//TESTA O VALOR ATUAL COM O VALOR ARMAZENADO
menor = j;
//ARMAZENA A NOVA POSIÇÃO
x=num[j];
//ARMAZENA O MENOR VALOR
}
}
num[menor] = num[i];
//TROCA DO MENOR VALOR NO VETOR
num[i] = x;
}
for (int i = 0; i < num.length; i++) {
System.out.print(num[i] + ” ” ); //IMPRESSÃO DO VETOR
}
}
Ordenação por trocas (bubble sort)
•
O método de ordenação por trocas consiste em comparar pares consecutivos de
valores e trocá-los de posição caso estejam, fora de ordem.
•
Uma forma de trabalhar com o algoritmo Bubble Sort é comparando os
elementos adjacentes (dois a dois), por exemplo:
•
Compara-se a primeira posição do vetor com a segunda, na segunda iteração
(repetição), compara-se a segunda posição do vetor com a terceira, e assim
sucessivamente.
•
O algoritmo Bubble Sort percorre todo o vetor diversas vezes, por isso, não é
recomendado o uso dele para aplicações que requerem velocidade ou trabalhem
com uma grande quantidade de dados.
Ordenação por troca
• Exemplo de ordenação por troca:
Posição
0
1
2
3
4
5
6
7
Valores Iniciais
23
4
33
45
19
12
28
40
Iteração 1
4
23
33
45
19
12
28
40
Iteração 2
4
23
33
19
45
12
28
40
Iteração 3
4
23
33
19
12
45
28
40
Iteração 4
4
23
33
19
12
28
45
40
Iteração 5
4
23
33
19
12
28
40
45
Iteração 6
4
23
19
33
12
28
40
45
Iteração 7
4
23
19
12
33
28
40
45
Iteração 8
4
23
19
12
28
33
40
45
Iteração 9
4
19
23
12
28
33
40
45
Iteração 10
4
19
12
23
28
33
40
45
Iteração 11
4
12
19
23
28
33
40
45
Ordenação por trocas em Java
public static void main(String[] args) {
int num[] = { 23, 4, 33, 45, 19, 12, 28, 40 }; // DECLARAÇÃO DO VETOR
int aux;
// VARIÁVEL DE APOIO
for (int i = 0; i < num.length; i++) {
for (int j = 0; j < num.length -1; j++) {
if (num[j] > num[j + 1]) {
aux = num[j];
num[j] = num[j + 1];
num[j + 1] = aux;
}
}
}
for (int i = 0; i < num.length; i++) {
System.out.print(num[i] + " ");
// IMPRESSÃO DO VETOR
}
}
Ordenação de Strings
• Na ordenação de Strings em Java devemos utilizar o método chamado
compareTo().
• Esse método lê a representação UNICODE das Strings envolvidas e
subtrai uma da outra, resultando um valor numérico do tipo inteiro, que
se for igual a 0 (zero) as duas Strings são iguais; se for menor de 0 (zero),
elas são ordenadas de forma crescente e se for maior do que 0 (zero) elas
estarão em ordem decrescente.
• Tenha em mente que as letras maiúsculas e minúsculas são diferentes,
estando as maiúsculas listadas a frente das minúsculas nas tabelas de
caracteres. Para evitar problemas é recomendado trabalhar utilizando os
métodos toUpperCase() ou toLowerCase() para fazer as conversões em
maiúsculas e minúsculas respectivamente.
Ordenação
(Exercício 1)
• Crie um programa em Java onde que um
usuário deva inserir 7 números inteiros e
possa escolher como quer ordená-los, em
ordem crescente ou decrescente.
Ordenação
(Exercício 2)
• Crie um programa em Java onde que um usuário
deverá inserir 6 nomes de pessoas. O programa
deverá mostrar os nomes listados em forma
crescente. Ex. :
1
Nome1
2
Nome2
...
...
6
Nome6
Busca
• Somente possuir os dados não ajuda em nada se o programador,
ou o usuário não souber como recuperá-los de forma eficiente.
• Imagine, por exemplo, uma festa com 100 convidados na qual não
se sabe quem eles são ou se foram convidados.
• Procurar nomes e números em listas parece ser algo trivial, porém,
quando a quantidade de dados é muito grande, são necessários
recursos adicionais para facilitar o procedimento.
Busca linear(sequencial)
• A maneira mais óbvia para se fazer uma busca é
comparar o elemento que se está procurando com
todos os elementos guardados, um a um, isto é,
procurar o elemento sequencialmente até que seja
encontrado.
• Quando o elemento é encontrado, retorna-se o valor
verdadeiro, que o indica o sucesso da busca e encerra
a estrutura de repetição.
Busca Linear em Java
public static String linear(int procura, int vetor[]) {
String status= "Não Encontrado";
for (int i = 0; i < vetor.length; i++) {
if(procura == vetor[i]){
status= "Encontrado”;
break;
}
}
return status;
}
Busca binária
• A busca linear é o método mais adequado quando não se tem
nenhuma informação a respeito da estrutura em que a busca será
realizada.
• Contudo se o elemento a ser procurado estiver nas ultimas
posições ou não estiver no conjunto, esse método poderá ser
demasiadamente demorado, pois ocorrerão comparações com
todos os elementos desse conjunto.
• Quando temos uma sequencia ordenada de elementos, existem
outros métodos de busca que são mais eficientes que a busca
linear.
Busca binária
• Considere uma conjunto ordenado de elementos de
qualquer tipo.
• Em vez de comparar o elemento procurado ao primeiro
elemento da sequência, pode-se compará-lo a um
elemento do meio da sequência.
• Se o elemento comparado é o desejado, a busca
termina; senão, pode-se verificar se o elemento
desejado é maior ou menor que o elemento encontrado.
Busca binária
• Como todos os elementos estão ordenados, essa verificação
elimina a metade da sequência onde o elemento pode não
estar.
• A segunda comparação será feita com o elemento do meio
da sequência que restou, e o procedimento anterior se
repetirá. Dessa forma, cada vez que o elemento não for
encontrado, o conjunto a ser pesquisado será reduzido pela
metade, aproximadamente, até que o elemento seja
encontrado ou até que a lista não possa ser mais dividida.
Busca binária
• Exemplo de busca binária:
• Procurando pelo número 40
Posição
0
1
2
3
4
5
6
7
Vetor
Ordenado
4
12
19
23
28
33
40
45
Iteração 1
4
12
19
23
28
33
40
45
Iteração 2
4
12
19
23
28
33
40
45
Iteração 3
4
12
19
23
28
33
40
45
Iteração 4
4
12
19
23
28
33
40
45
Iteração 5
4
12
19
23
28
33
40
45
Iteração 6
4
12
19
23
28
33
40
45
Iteração 7
4
12
19
23
28
33
40
45
Busca binária
• Exemplo de busca binária:
• Procurando pelo número 4
Posição
0
1
2
3
4
5
6
7
Vetor
Ordenado
4
12
19
23
28
33
40
45
Iteração 1
4
12
19
23
28
33
40
45
Iteração 2
4
12
19
23
28
33
40
45
Iteração 3
4
12
19
23
28
33
40
45
Iteração 4
4
12
19
23
28
33
40
45
Iteração 5
4
12
19
23
28
33
40
45
Iteração 6
4
12
19
23
28
33
40
45
Iteração 7
4
12
19
23
28
33
40
45
Busca binária em Java
public static String buscaBinaria(int procura, int vetor[]) {
int inicio = 0;
int fim = vetor.length - 1;
int meio;
String status = "Não Encontrado";
while (inicio <= fim) {
meio = (inicio + fim) / 2;
if (procura == vetor[meio]) {
status = "Encontrado”;
}
if (procura < vetor[meio]) {
fim = meio - 1;
} else {
inicio = meio + 1;
}
}
return status;
}
Busca
(Exercício 3)
• Dado a lista de uma festa com os nomes abaixo:
(Carlos, Ana, Fernanda, Augusto, Jose, Mario, Beatriz,
Fernando, Miguel, Lucas, Pedro, Tiago, Eduarda)
• Crie um programa em Java que deverá retornar
se o nome digitado pelo usuário está contido na
lista da festa.