AULA TEÓRICA 8

Tema 3. (continuação) Vectores e Matrizes

Ø Algoritmo de procura de valor maior/menor num array.
Ø Array bidimensional

1
 Algoritmo de procura de valor maior / menor num array
Para encontrar a posição do elemento cujo valor é o maior num array de
inteiros poderia usar o método seguinte:
. . .
float[] y = new float[100];
float maiorNum = y[0]; byte indice_do_maior = -1;
. . .
for (byte i=0; i < y.length; i++)
{ if (y[i] > maiorNum)
{ maiorNum = y[i];
indice_do_maior = i; //posição do elemento
}
} . . .
Obs. Para procura do valor menor usa-se a condição (<)
Ordenação por borbulhamento (Bubble sort)
Um problema fundamental em computação é a ordenação de dados. Existem
vários métodos de ordenação: por borbulhamento (bubble sort), por selecção
(selection sort), tipo Shell (shell sort), shaker sort, quick sort, etc.
A técnica usa dois ciclos for encadeados para fazer várias passagens pelo
array. O ciclo externo controla o número de passagens pelo array. 2
O ciclo interno controla as comparações e trocas (se são necessárias) dos
elementos durante cada passagem. Em cada passagem, pares de elementos
sucessivos são comparados: se um par estiver na ordem crescente (ou os
valores forem iguais), a bubble sort deixa os valores como estão, se um par
estiver na ordem decrescente, a bubble sort troca seus valores no array. O
algoritmo é muito simples, mas lento.
import java.util.Random; import javax.swing.JOptionPane;
public class ArrayOrdenacaoBubbleSort
{ public static void main (String args[])
{ //criação do array
int q = 200;
int v[] = new int [q];
Random r = new Random();
for (int i = 0; i < q; i++)
{ v[i] = r.nextInt(55); } //gere números aleatorios
// inteiros na faixa de zero a 55

//visualização do conteúdo do array criado

String str = "Conteudo do array original:\n”;
for (int k=0; k < v.length; k++)
{ str += v[k] + ", "; }

JOptionPane.showMessageDialog(null,str);
3
 //ordenação
int aux;
for (int i = 1; i < v.length; i++ )
for (int j = 0; j < v.length-1; j++ )
{ if (v[j] > v[j+1])
{ aux = v[j];
v[j] = v[j+1];
v[j+1] = aux;
}
}
str = ”\nConteudo do array ordenado:\n”;
for (int k=0; k < v.length; k++)
{ str += v[k] + ", "; }
JOptionPane.showMessageDialog(null,str);
}
}

4
 Array bidimensional
Um array unidimensional pode armazenar elementos de tipos simples e
também elementos que são objectos. Um caso particular quando cada
elemento de array é um array, criando-se assim um array bidimensional, ou
matriz, com linhas e colunas.
precos

[0] [1]

[0] precos[0][0] precos[0][1]

[1] precos[1][0] precos[1][1]

float precos[][];
precos = new float [3][2]; [2] precos[2][0] precos[2][1]
ou
float[][] precos = new float [3][2];
ou
float [][] precos={{120.54,100.34},{100.12,98.34},{157.89,180.12}};

5
Cada elemento do array bidimensional pode ser acedido através de dois
índices, um que indica a linha e outro a coluna.

Por exemplo, o elemento precos[2][1], de acordo com a ultima declaração,

possui o valor 180.12.

É possível obter:

o número de linhas dum array através de instrução:

int numLinhas = precos.length;
e o número de colunas dum array através de instrução:
int numColunas = precos[0].length;

Para aceder aos elementos do array deve se utilizar dois ciclos for, um
dentro do outro. O primeiro serve para fazer variar linhas e o segundo para
fazer variar colunas.

O exemplo a seguir preenche um array de 3 linhas e 2 colunas com valores

aleatórios, na faixa de 0 a 150, geridos pelo método nextInt() da classe
Random, visualiza o conteúdo do array no ecrã na forma de tabela e calcula a
soma de elementos que se encontram numa coluna escolhida pelo utilizador.
6
import java.util.Random;
import javax.swing.JOptionPane;
public class ArrayBi
{ public static void main (String[] args)
{ //criação do array
int[][] t = new int [3][2];
Random r = new Random();
float soma = 0;
for (byte i=0; i < t.length; i++)
for (byte j=0; j < t[0].length; j++)
{ t[i][j]= r.nextInt(150); } //gere números aleatorios

//visualização do conteúdo do array criado

String s = "Conteudo do array criado:\n";
for (byte i=0; i < t.length; i++)
{ for (byte j=0; j < t[0].length; j++)
{ s += t[i][j] + " "; }
s += "\n";
}
JOptionPane.showMessageDialog(null,s);
7
//calculo da soma de uma coluna
byte nc=0;
do
{ nc = Byte.parseByte(JOptionPane.showInputDialog("Soma de que
coluna pretende(1-2)? "));
if (nc <= 0 || nc > t[0].length)
JOptionPane.showMessageDialog(null,"Num. de coluna invalida,
deve ser entre 1 e "+t[0].length);
}
while (nc <= 0 || nc > t[0].length);
for (byte i=0; i < t.length; i++)
{ soma += t[i][nc-1]; }
JOptionPane.showMessageDialog(null,"Soma de valores da coluna "+
nc+"="+soma);
}
}

Podemos realizar cálculos ou maipular elementos apenas de uma coluna ou de

uma linha de um array bidimensional.
8
Referência bibliográfica:
António José Mendes; Maria José Marcelino.
“Fundamentos de programação em Java 2”. FCA. 2002.

Elliot Koffman; Ursula Wolz.

“Problem Solving with Java”. 1999.
John R. Hubbard.
“Theory and problems of programming with Java”. Schaum’s Outline series. McGraw-Hill.
H. Deitel; P. Deitel.
“Java, como programar”. 4 edição. 2003. Bookman.
Rui Rossi dos Santos.
“Programando em Java 2– Teoria e aplicações”. Axcel Books. 2004

9
TPC

Escrever um programa em Java para resolução do seguinte

problema:

Ø Armazenar quaisquer valores num array de N elementos.

Determinar a quantidade de números negativos existentes no
array. Visualizar o conteúdo do array criado.

Ø Multiplicar dois arrays de comprimento igual, criando um novo

3-o array. Conteúdo do 1-o são números aleatórios na faixa
de zero a cem. Conteúdo do 2-o são múltiplos de 5.

10