Procura em vectores

2007/08
A.E.D.
F.S.B.

Para procurar um elemento num vector vai-se

usar como exemplo um vector de inteiros

Mas tudo o que se falará serve, com as devidas
adaptações, a todo o tipo de vectores

Há duas considerações a fazer quando se
procura um elemento num vector:

O vector não está ordenado

O vector está ordenado

Procura em vectores
2007/08
A.E.D.
F.S.B.

Supondo que o vector não está ordenado existe

apenas um tipo de procura:

Procura linear

Nesta procura o vector é percorrido, elemento a elemento,
desde o primeiro elemento até ao último

Termina-se a procura quando ocorre uma de duas situações:
 o elemento é encontrado
 todo o vector foi pesquisado e não se encontrou o elemento
 Procura em vectores : linear
2007/08
A.E.D.
F.S.B.

O algoritmo de procura linear é, supondo que:

x é o elemento a procurar

vect é o vector onde procurar

dim é a dimensão do vector

O índice do primeiro elemento é 0 (zero)

i = 0
ENQUANTO i < dim E vect[ i ] != x FAZER
i = i +1
FIM

Se i >= dim não encontrou

Se i < dim é porque encontrou o elemento x na
posição i

Procura em vectores : linear

2007/08
A.E.D.
F.S.B.

O algoritmo de procura linear pode ser

implementado pelo seguinte método que:

Devolve o índice onde encontrou o elemento

Devolve –1 (índice inválido para qualquer vector) se
não encontrou

int procuraLinear( int oVector[], int x ) {

int i = 0;
while( i < oVector.lenght && oVector[ i ] != x )
i++;

if( i >= oVector.length )

return –1;
return i;
}
 Procura em vectores : linear
2007/08
A.E.D.
F.S.B.

Exemplo de uso:

public static void main( String args[] ) {

int vect[] = {1, 2 ,3 ,5, 3, 10, 8, 12, 17, 4};

int res, x;
Keyboard keyboard = new Keyboard();

System.out.print(“numero a procurar: “);

keyboard.readInt( x );

res = procuraLinear( vect, x );

if( res == -1 )
System.out.println( x + “ não foi encontrado!” );
else
System.out.println( x + “ foi encontrado na posição ” + res );
}

Procura em vectores : linear

2007/08
A.E.D.
F.S.B.

Os exemplos e o algoritmo apresentados

referem-se apenas a encontrar a PRIMEIRA
ocorrência de x no vector

Fica como exercício alterar o algoritmo para
procurar a ÚLTIMA ocorrência de x

Existe uma outra versão do algoritmo que evita
as duas comparações no ciclo while:

Mais rápida (pode ser significativo para vectores
grandes)

Envolve aumentar o vector de uma posição e colocar
o valor x nessa posição - assim a procura é sempre
até encontrar o valor de x

Também fica como exercício ☺
 Procura em vectores
2007/08
A.E.D.
F.S.B.

Supondo que o vector está ordenado podem-se

aplicar as seguintes procuras:

Procura linear (já descrita)

Procura binária:

Nesta pesquisa o vector é dividido em zonas a procurar

A divisão pode ser feita de qualquer maneira, mas os
melhores resultados (em média) obtêm-se quando se divide o
vector (e as zonas seguintes) em duas partes

Comparando o elemento a procurar (x) com o elemento no
intervalo escolhe-se a próxima zona a dividir:
 Se x for menor procurar na zona da esquerda
 Se x for maior procurar na zona da direita

E assim sucessivamente até se encontrar o valor ou a zona
ser de apenas um elemento

Procura em vectores : binária

2007/08
A.E.D.
F.S.B.

O algoritmo de procura linear é, supondo que:

x é o elemento a procurar

vect é o vector onde procurar

dim é a Dimensão do vector

O índice do primeiro elemento é 0 (zero)
encontrado = FALSO
esq = 0
dir = dim-1
ENQUANTO esq <= dir E NÃO encontrado FAZER
meio = (esq + dir) / 2
SE vect[meio] = x ENTAO encontrado = VERDADE
SENAO SE vect[meio] < x ENTAO esq = meio+1
SENAO dir = meio-1
FIM

Se encontrado = FALSO não encontrou

Se encontrado = VERDADE é porque encontrou o
elemento x na posição Meio
 Procura em vectores : binária
2007/08
A.E.D.
F.S.B.

O algoritmo de procura binária pode ser

implementado pelo seguinte método que:

Devolve o índice onde encontrou o elemento

Devolve –1 se não encontrou
int procuraBinaria( int oVector[], int x ) {
boolean encontrou = false;
int esq = 0;
int dir = oVector.length-1;
int meio;
while( esq <= dir && !encontrou ) {
meio = (esq + dir) / 2;
if( oVector[ meio ] == x ) encontrou = true;
else if( oVector[ meio ] < x ) esq = meio + 1;
else dir = meio - 1;
}

if( !encontrou )
return –1;
return meio;
}

Procura em vectores : binária

2007/08
A.E.D.
F.S.B.

Exemplo de procura do nº 10

2 3 5 7 9 10 11 12 17 19 21 28 30 33 38 42 45 55
esq dir
1ª iteração meio
2 3 5 7 9 10 11 12 17 19 21 28 30 33 38 42 45 55
esq dir
2ª iteração meio
2 3 5 7 9 10 11 12
esq dir
3ª iteração meio
9 10 11 12

Encontrou
 Procura em vectores : binária
2007/08
A.E.D.
F.S.B.

Exemplo de procura do nº 4

2 3 5 7 9 10 11 12 17 19 21 28 30 33 38 42 45 55
esq dir
1ª iteração meio
2 3 5 7 9 10 11 12 17 19 21 28 30 33 38 42 45 55
esq dir
2ª iteração meio
2 3 5 7 9 10 11 12
esq dir
3ª iteração meio
2 3 5
esq
dir
4ª iteração meio
5
dir esq
5ª iteração Não encontrou

Procura em vectores : Binária

2007/08
A.E.D.
F.S.B.

Os exemplos e o algoritmo apresentados

referem-se apenas a encontrar UMA ocorrência
de x no vector, não sendo a primeira nem a
última

Fica como exercício alterar o algoritmo para
procurar a primeira ocorrência de x

E também como exercício procurar a última
 Procura em vectores
2007/08
A.E.D.
F.S.B.

Comparando os dois algoritmos de procura:

A binária é mais rápida (em média)

A binária só pode ser utilizada em vectores ordenados

A linear pode ser usada em qualquer vector

A linear encontra a primeira ocorrência de x enquanto
a binária apenas encontra uma ocorrência de x

Ordenação de vectores
2007/08
A.E.D.
F.S.B.

Ter a informação ordenada é muito mais

vantajoso:

Imagine-se a procurar um nome numa lista telefónica
se esta não estivesse ordenada alfabeticamente
2007/08
A.E.D.
F.S.B. Ordenação de vectores : inserção

Ordenação por inserção

Neste caso percorre-se o vector e vai-se colocando
cada elemento na sua posição correcta

considerando-se apenas os que estão à sua esquerda

Ao inserir um elemento os maiores são deslocados
para a direita

2007/08
A.E.D.
F.S.B. Ordenação de vectores : inserção

Algoritmo de ordenação por inserção directa,
assumindo:

vect é o vector a ordenar

dim é a dimensão do vector

O índice do primeiro elemento é 0 (zero)

PARA i = 1 ATÉ dim –1 FAZER

x = vect[i]
inserir x na posição correcta (k) entre vect[0] e vect[i]
FIM

A posição correcta k é tal que:

x >= v[ k-1 ]

x <= v[ k+1 ]
2007/08
A.E.D.
F.S.B. Ordenação de vectores : inserção

Exemplificação do algoritmo

1ª iteração 2ª iteração 3ª iteração 4ª iteração 5ª iteração

9 9 3 3 3 3 3 3 2 2 2
3 3 9 9 5 5 5 5 3 3 3
5 5 5 5 9 9 9 9 5 5 5
11 11 11 11 11 11 11 11 9 9 7
2 2 2 2 2 2 2 2 11 11 9
7 7 7 7 7 7 7 7 7 7 11

2007/08
A.E.D.
F.S.B. Ordenação de vectores : inserção

O algoritmo de ordenação por inserção pode ser
implementado pelo seguinte método:

void ordenaInsercaoDirecta( int oVector[] ) {

for( int i = 1; i < oVector.lenght; i++ ) {

int x = oVector[ i ];
int j = i;
while( j > 0 && oVector[ j-1 ] > x )
{
oVector[ j ] = oVector[ j-1 ];
j--;
}
oVector[ j ] = x;
}
}

Porque não começa o for em i = 0?

2007/08
A.E.D.
F.S.B. Ordenação de vectores : inserção

Exemplo de uso

public static void main( String args[] ) {

int v[13] = { 2, 4, 65, 54, 34, 23, 90, 12, 6, 78, 87, 26, 42 };

ordenaInsercaoDirecta( v );

for( int i=0; i < v.length; i++)

System.out.println("v[" + i + "] = " + v[i] );

2007/08
A.E.D.
F.S.B. Ordenação de vectores : selecção

Ordenação por selecção

Neste caso percorre-se o vector, procurando o menor
elemento e coloca-se este na primeira posição

O elemento na primeira posição é colocado na
posição ocupada anteriormente pelo menor

Repete-se para os restantes elementos
2007/08
A.E.D.
F.S.B. Ordenação de vectores : selecção

Algoritmo de ordenação por selecção
assumindo:

vect é o vector a ordenar

dim é a dimensão do vector

O índice do primeiro elemento é 0 (zero)

PARA i = 0 ATÉ dim - 1 FAZER

k = índice do menor elemento de vect[i] a vect[ dim - 1 ]
TROCAR vect[ i ] com vect[ k ]
FIM

2007/08
A.E.D.
F.S.B. Ordenação de vectores : selecção

Exemplificação do algoritmo

1ª iteração 2ª iteração 3ª iteração 4ª iteração 5ª iteração

9 9 2 2 2 2 2 2 2 2 2
menor

3 3 3 3 3 3 3 3 3 3 3
menor

5 5 5 5 5 5 5 5 5 5 5
11 11 11 11 11 11 11 11 7 7 7
menor

menor

2 2 9 9 9 9 9 9 9 9 9
menor

7 7 7 7 7 7 7 7 11 11 11
2007/08
A.E.D.
F.S.B. Ordenação de vectores : selecção

O algoritmo de ordenação por selecção pode ser
implementado pela seguinte função:

void ordenaSeleccao( int oVector[] ) {

for( int i = 0; i < oVector.length - 1; i++ ) {

int min = i;
for( int j = i + 1; j < oVector.length; j++ )
if( oVector[ min ] > oVector[ j ] )
min = j;
int aux = oVector[ min ];
oVector[ min ] = oVector[ i ];
oVector[ i ] = aux;
}
}

2007/08
A.E.D.
F.S.B. Ordenação de vectores : permutação

Ordenação por permutação

Neste caso percorre-se o vector, do último para o
primeiro, comparando elementos consecutivos dois a
dois e trocando-os se estiverem na ordem inversa

Após a primeira iteração o menor valor estará na
primeira posição, pelo que as repetições seguintes,
deverão ter em conta apenas os restantes elementos
e assim sucessivamente

Chama-se a este algoritmo Bubblesort
2007/08
A.E.D.
F.S.B. Ordenação de vectores : permutação

Algoritmo da ordenação por permutação
(bubblesort) assumindo:

vect é o vector a ordenar

dim é a dimensão do vector

O índice do primeiro elemento é 0 (zero)

PARA i = 1 ATÉ dim - 1 FAZER

PARA j = dim - 1 ATÉ i FAZER
SE vect[ j – 1 ] > vect[ j ] FAZER
TROCAR vect[ i ] COM vect[ j ]
FIM

2007/08
A.E.D.
F.S.B. Ordenação de vectores : permutação

Pode-se fazer uma melhoria óbvia ao algoritmo:

Se não houve permutações é porque o vector já está
ordenado

ordenado = FALSO
i = 0
ENQUANTO i < dim-1 E NÃO ordenado FAZER
ordenado = VERDADE
PARA j = dim - 1 ATÉ i + 1 FAZER
SE vect[ j - 1 ] > vect[ j ] FAZER
TROCAR vect[ i ] COM vect[ j ]
ordenado = FALSO
FIM
i = i +1
FIM
2007/08
A.E.D.
F.S.B. Ordenação de vectores : permutação

Exemplificação do algoritmo
1ª iteração 2ª iteração

- não há mais comparações a fazer

9 9 9 9 9 9 2 2 2 2 2 2

Terminava pelos dois motivos:

3 3 3 3 3 2 9 9 9 9 9 3
5 5 5 5 2 3 3 3 3 3 3 9
11 11 11 2 5 5 5 5 5 5 5 5

- não ouve permutações

2 2 2 11 11 11 7 7 7 7 7 7
7 7 7 7 7 7 11 11 11 11 11 11

3ª iteração 4ª iteração 5ª iteração

2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3
9 9 9 5 5 5 5 5 5
5 5 5 9 9 9 7 7 7
7 7 7 7 7 7 9 9 9
11 11 11 11 11 11 11 11 11

2007/08
A.E.D.
F.S.B. Ordenação de vectores : permutação

O algoritmo de ordenação Bubblesort pode ser
implementado pelo seguinte método:
void bubbleSort( int oVector[] ) {
boolean ordenado = false;
int i = 0;

while( i < oVector.length - 1 && !ordenado ) {

ordenado = true;
for( int j = oVector.lenght - 1; j > i; j-- ) {
if( oVector[ j – 1 ] > oVector[ j ] ) {
int aux = oVector[ j – 1 ];
oVector[ j – 1 ] = oVector[ j ];
oVector[ j ] = aux;
ordenado = false;
}
}
i++;
}
}