Matrizes
Os vetores, como vimos na aula passada, são estruturas capazes de armazenar
diversos valores do mesmo tipo. Assim como os vetores, existem as matrizes, que
também são estruturas capazes de armazenar diversos valores do mesmo tipo. A
diferença entre eles é que os vetores são estruturas unidimensionais, já as
matrizes são estruturas multidimensionais.
Na linguagem algorítmica, as matrizes são declaradas de forma similar aos
vetores. A declaração de uma matriz é feita da seguinte forma:
<identificador>[<tam_1>][<tam_2>][...][<tam_n>]: <tipo>;
Na qual:
•
•
•
•
•
identificador: identificador (ou nome) da matriz;
tam_1: número de elementos da primeira dimensão da matriz;
tam_2: número de elementos da primeira dimensão da matriz;
tam_n: número de elementos da dimensão n da matriz;
tipo: tipo de cada elemento da matriz.
Por exemplo:
m[3][2]: inteiro;
declara uma variável matriz de nome m bidimensional (duas dimensões). Essa
variável terá "dentro" dela outras 6 variáveis inteiras, a cada uma dessas variáveis
damos o nome de elemento da matriz. Essa variável pode ser representada da
seguinte forma, utilizando a convenção que o primeiro índice representa as linhas
e o segundo as colunas da matriz:
A variável m é composta por outras 6 variáveis inteiras representadas através dos
6 quadrados da figura acima. Cada quadrado representa um elemento da matriz.
Para acessar cada elemento da matriz m precisamos de dois números porque a
matriz m é bidimensional. Esses números são chamados de índices da matriz.
De forma similar aos vetores, o índice inicial é sempre zero, e o índice final
depende do tamanho da dimensão. No caso da matriz m, as linhas são
númeradas de 0 a 2 (dimensão linha de tamanho 3), e as colunas são numeradas
de 0 a 1 (dimensão coluna de tamanho 2).
Para ler ou escrever variáveis do tipo matriz através dos comandos leia e
escreva NÃO podemos simplesmente fazer:
leia(m);
escreva(m);
Para ler ou escrever em uma matriz é necessário ler ou escrever em cada um de
seus elementos individualmente. Para acessar um elemento de uma matriz basta
utilizar o identificador da matriz e seus índices (coordenada), na seguinte sintaxe:
<identificador>[<posição_1>][<posição_2>][...][<posição_n>];
•
•
•
posição_1: índice da primeira dimensão da matriz da matriz;
posição_2: índice da segunda dimensão da matriz;
posição_n: valor inicial do índice da dimensão n da matriz;
Por exemplo:
m[2][1];
No nosso exemplo, m[2][1] é o elemento da terceira linha e segunda coluna da
matriz m. Esse elemento é uma variável do tipo inteiro, porque declaramos, em
nosso exemplo, os elementos da matriz m de tipo inteiro. Assim como é possível
atribuir valores, ler e escrever no conteúdo de variável inteira, também é possível
atribuir, ler e escrever no conteúdo de m[2][1]. Por exemplo, se executarmos a
seguinte atribuição:
m[2][1]
15;
Então o valor 15 é atribuído ao elemento da terceira linha e segunda coluna da
matriz m. Dessa forma, a matriz m é modificada e pode ser representada da
seguinte forma:
Para ler valores do teclado e armazenar esses valores em uma matriz é
necessário fazê-lo elemento a elemento da matriz. Por exemplo, para ler 6 valores
do teclado e armazená-los na matriz m, pode-se fazer:
para(i 0; i < 3; i++)
{
para(j 0; j < 2; j++)
{
leia(m[i][j]);
}
}
O trecho de algoritmo acima lê 6 valores do teclado e os armazena na matriz m.
Note que foi preciso utilizar dois comandos para, um dentro do outro. Isto porque
o comando para mais externo controla as linhas da matriz m e o comando para
mais interno controla as colunas. Assim, quando a variável i do comando para
mais externo vale 0 (primeira linha), a variável j do comando para mais interno vai
variar de 0 até 1 (vai da coluna 0 até a coluna 1). Os valores lidos serão
armazenados na matriz m na seguinte ordem:
m[0][0]
m[0][1]
m[1][0]
m[1][1]
m[2][0]
m[2][1]
Ainda, é possível fazer o mesmo para escrever os 6 elementos da matriz m na tela
do computador.
para(i 0; i < 3; i++)
{
para(j 0; j < 2; j++)
{
escreva(m[i][j]);
}
}
A seguir vamos mostrar um exemplo de uma matriz de três dimensões, lembrando
que o tipo matriz é multidimensional, ou seja, podemos declarar uma matriz com
quantas dimensões quisermos, apesar da matriz bidimensional ser mais
comumente utilizada.
Exemplo:
ma[3][3][2]: inteiro;
A matriz ma declarada acima possui três dimensões e pode ser representada
graficamente pela figua abaixo:
Na figura abaixo, o elemento da matriz ma onde está armazenado o valor 33
corresponde ao elemento ma[0][1][1].
Exercício 1
Faça um algoritmo que leia uma matriz bidimensional 3x4, em seguida, calcule e
mostre sua transposta.
Exemplo: a figura abaixo mostra a matriz m e sua transposta mt.
Note que:
•
•
•
•
•
•
•
•
•
•
•
•
o elemento m[0][0] corresponde ao elemento mt[0][0]
o elemento m[0][1] corresponde ao elemento mt[1][0]
o elemento m[0][2] corresponde ao elemento mt[2][0]
o elemento m[0][3] corresponde ao elemento mt[3][0]
o elemento m[1][0] corresponde ao elemento mt[0][1]
o elemento m[1][1] corresponde ao elemento mt[1][1]
o elemento m[1][2] corresponde ao elemento mt[2][1]
o elemento m[1][3] corresponde ao elemento mt[3][1]
o elemento m[2][0] corresponde ao elemento mt[0][2]
o elemento m[2][1] corresponde ao elemento mt[1][2]
o elemento m[2][2] corresponde ao elemento mt[2][2]
o elemento m[2][3] corresponde ao elemento mt[3][2]
Ou seja, o elemento da segunda coluna e terceira linha da matriz m (m[1][2]),
torna-se o elemento de terceira linha e segunda coluna na matriz mt (mt[2][1]).
Para iniciar nosso algoritmo precisamos declarar duas matrizes, que chamaremos
de m e mt.
m[3][4]: inteiro;
mt[4][3]: inteiro;
Para ler 12 valores e armazenar na matriz m deve-se fazer:
para(i 1; i < 3; i++)
{
para(j 1; j < 4; j++)
{
leia(m[i][j]);
}
}
Para calcular a matriz transposta mt da matriz m devemos fazer:
para(i 1; i < 4; i++)
{
para(j 1; j < 3; j++)
{
mt[i][j]
m[j][i];
}
}
Por fim, é necessário mostrar a matriz transposta mt. Para isso:
para(i 1; i < 4; i++)
{
para(j 1; j < 3; j++)
{
escreva(mt[i][j]);
}
}
Juntando tudo, nós temos o seguinte algoritmo:
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
| Algoritmo transposta;
| {
|
m[3][4]: inteiro;
|
m[4][3]: inteiro;
|
i, j: inteiro;
|
|
|
/* Leitura dos valores e armazenamento na matriz m */
|
para(i 1; i < 3; i++)
|
{
|
para(j 1; j < 4; j++)
|
{
|
leia(m[i][j]);
|
}
|
}
|
|
/* Cálculo da transposta */
|
para(i 1; i < 4; i++)
|
{
|
para(j 1; i < 3; j++)
|
{
|
mt[i][j]
m[j][i];
23
24
25
26
27
28
29
30
31
32
33
34
|
}
|
}
|
|
/* Mostra a transposta */
|
para(i 1; i < 4; i++)
|
{
|
para(j 1; j < 3; j++)
|
{
|
escreva(mt[i][j]);
|
}
|
}
| }
Exercícios
1. Faça um algoritmo e um programa capaz de ler uma matriz A e uma matriz
B com três linha e cinco colunas, em seguida faça a soma das matrizes e
armazene na matriz C.
2. Faça um algoritmo e um programa capaz de ler uma matriz A de ordem
5x5, em seguida calcule a multiplicação dos elementos da diagonal
principal.