Matrizes em C

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Matrizes em C 
1 Variáveis Compostas Homogêneas Multidimensionais 
Em C, o conceito de Variáveis Compostas Homogêneas Unidimensionais ou 
Vetores, pode ser estendido para N dimensões, cujas posições individuais são acessadas por 
N índices, originando as Variáveis Compostas Homogêneas Multidimensionais. 
A sintaxe geral de declaração em C é a seguinte: 
 
tipo-de-dado nome[dimensão1][dimensão2]... [dimensãoN]; 
 
onde: 
nome: é o nome da variável composta homogênea multidimensional; 
dimensão1, dimensão2, ..., dimensãoN: é a quantidade máxima de posições (índices) de cada 
dimensão; 
tipo-de-dado: é um tipo de dado válido em C. 
 
As Variáveis Compostas Homogêneas Multidimensionais de 2 dimensões são as 
mais utilizadas, sendo denominadas Variáveis Compostas Homogêneas Bidimensionais ou 
Matrizes. Em C, uma matriz pode ser vista como um vetor de vetores unidimensionais. 
2 Variáveis Compostas Homogêneas Bidimensionais – Matrizes em C 
As Variáveis Compostas Homogêneas Bidimensionais ou Matrizes correspondem a 
posições de memória (variáveis) identificadas por um mesmo nome, onde uma posição 
individual é acessada por dois índices, um para indicar a linha e outro para indicar a coluna, e 
cujo conteúdo é do mesmo tipo de dado. Em outras palavras, uma matriz tem a estrutura de 
uma tabela com M linhas e N colunas. 
Sintaxe de declaração em C: 
 
tipo-de-dado nome[linhas][colunas]; 
 
onde: 
nome: é o nome da matriz; 
linhas: é a quantidade máxima de linhas da matriz; 
colunas: é a quantidade máxima de colunas da matriz; 
tipo-de-dado: é um tipo de dado válido em C. 
 
 A referência ao conteúdo do elemento da linha m e coluna n de uma matriz tem a 
sintaxe: 
 2 
 
nome[m][n] 
 
onde: 
nome: é o nome da matriz; 
m é o índice da linha, que corresponde a um número inteiro ou uma variável do tipo inteiro. 
n é o índice da coluna, que corresponde a um número inteiro ou uma variável do tipo inteiro. 
 
Em C, o primeiro elemento tem o índice da linha e da coluna iguais a 0. 
 
 Exemplo de matriz: 
 
/* Declaração de uma matriz de nome mat com 2 linhas e 10 colunas que 
armazena elementos do tipo real */ 
float mat[2][10]; 
 
Esquematicamente tem-se: 
 
 colunas 
 0 1 2 3 4 5 6 7 8 9 
0 1.5 9.0 5.0 4.0 8.0 6.5 3.5 2.0 5.0 1.0 
mat 
linhas 
1 5.5 6.0 9.0 2.5 4.5 9.5 7.0 8.5 7.5 3.0 
 
 
 
 
Para atribuir um valor à linha m e coluna n de uma matriz, usa-se a seguinte sintaxe: 
 
 nome[m][n] = valor; 
 
onde: 
nome: é o nome da matriz; 
m é o índice da linha, que corresponde a um número inteiro ou uma variável do tipo inteiro. 
n é o índice da coluna, que corresponde a um número inteiro ou uma variável do tipo inteiro. 
valor é uma variável ou um valor do mesmo tipo de dado da matriz. 
 
 Considerando a matriz do exemplo anterior, para atribuir o valor 9.5 para a posição 
correspondente a linha 1 e coluna 5, faz-se: 
 
mat[1][5] = 9.5; 
3 Usando Matrizes 
Assim como um vetor, uma matriz é usada para manter uma grande quantidade de 
elementos de dados na memória e para referenciar todos os elementos de maneira uniforme. A 
diferença é que para referenciar um elemento em um vetor basta um índice e em uma matriz 
são necessários dois índices. 
Supor a necessidade de ler 50 notas, para cada um dos 5 cursos de uma universidade. 
Para cada curso deve-se calcular a média aritmética das 50 notas e determinar o quanto cada 
nota se desvia dessa média. Nesse caso é necessário que, para cada um dos 5 cursos as 50 
notas lidas sejam armazenadas em variáveis para que o desvio seja calculado após o cálculo 
da média aritmética dos 5 cursos. Utilizar 250 variáveis para armazenar o total de 250 notas 
seria uma solução, mas o código do programa ficaria um tanto extenso, pois além de declarar 
mat[1][5] 
 3 
250 variáveis, seria necessário escrever código para 250 leituras de variáveis e 250 cálculos 
de desvios. Então, a solução é agrupar as 250 notas em uma matriz onde as linhas referenciam 
os cursos e as colunas as notas (ou vice-versa). 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[5][50] /* matriz de notas */: numérico real; 
 i, j /* índices da matriz */: numérico inteiro; 
 /* Obtendo as notas para cada curso */ 
para i ← 0 até 4 passo 1 faça /* para cada curso */ 
início 
 escreva(“Notas do curso ”,i); 
 para j ← 0 até 49 passo 1 faça /* lê as notas */ 
 início 
 escreva(“Digite uma nota”); 
 leia(nota[i][j]); 
 fim 
 fim 
 /* Cálculo das médias e desvios para cada curso */ 
para i ← 0 até 4 passo 1 faça /* para cada curso */ 
início 
 /* Cálculo da média */ 
 soma ← 0; /* para a sumarização das notas do curso i */ 
 para j ← 0 até 49 passo 1 faça 
 soma ← soma + nota[i][j]; 
 media ← soma/50; /* média das notas do curso i */ 
 escreva(“Media = ”, media); 
 /* Cálculo do desvio */ 
 para j ← 0 até 49 passo 1 faça 
 início 
desvio ← nota[i][j] – media; 
escreva(“Desvio da nota ”, nota[i][j], desvio); 
 fim 
 fim 
fim 
 
Em C fica: 
#include <stdio.h> 
 
 main() 
{ 
 float soma, media, desvio, nota[5][50] /* matriz de notas */; 
 int i, j /* índices da matriz */; 
 /* Obtendo as notas para cada curso */ 
for(i = 0; i <= 4; i++) /* para cada curso */ 
{ 
 printf(“Notas do curso %d:\n”, i); 
 for(j = 0; j <= 49; j++) /* lê as notas */ 
 { 
 printf(“Digite uma nota: ”); 
 scanf(“%f”, &nota[i][j]); 
 } 
 } 
 /* Cálculo das médias e desvios para cada curso */ 
for(i = 0; i <= 4; i++) /* para cada curso */ 
{ 
 /* Cálculo da média */ 
 soma = 0; /* para a sumarização das notas do curso i */ 
 4 
 for(j = 0; j <= 49; j++) 
 soma = soma + nota[i][j]; 
 media = soma/50; /* média das notas do curso i */ 
 printf(“\nMedia = %f”, media); 
 /* Cálculo do desvio */ 
 for(j = 0; j <= 49; j++) 
 { 
desvio = nota[i][j] – media; 
printf(“\nDesvio da nota %f = %f”, nota[i][j], desvio); 
 } 
 } 
} 
 
É possível escrever o algoritmo anterior, solicitando do usuário a quantidade de cursos 
e de notas ao invés de fixar em 5 e 50, respectivamente. O problema é que uma matriz tem 
que ter um número máximo de linhas e colunas e, nesse caso, é necessário garantir que o 
usuário entre com a quantidade de cursos e de notas menor ou igual ao número máximo de 
linhas e colunas, respectivamente. Ou seja, não há necessidade de utilizar todas as posições de 
uma matriz, mas nunca se deve utilizar posições além do número máximo de linhas e colunas. 
O número mínimo de linhas e colunas também deve ser garantido – maior que 0. 
 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[5][50] /* matriz de notas */: numérico real; 
 l, c, i, j /* índices da matriz */: numérico inteiro; 
 /* Entrada da quantidade de cursos e de notas e verificação dos 
 limites da matriz */ 
 repita 
 escreva(“Digite o número de cursos (entre 1 e 5) e o número 
de notas (entre 1 e 50): ”); 
 leia(l); 
 leia(c); 
 se (l > 5 ou l ≤ 0 ou c > 50 ou c ≤ 0) 
 então escreva(“Quantidade inválida”); 
 até (l > 0 e l ≤ 5 e c > 0 e c ≤ 50); 
 /* Obtendo as notas para cada curso */ 
para i ← 0 até l-1 passo 1 faça /* para cada curso */ 
início 
 escreva(“Notas do curso ”,i); 
 para j ← 0 até c-1 passo 1 faça /* lê as notas */ 
 início 
 escreva(“Digite uma nota”); 
 leia(“%f”, &nota[i][j]); 
 fim 
 fim 
 /* Cálculo das médias e desvios para cada curso */ 
para i ← 0 até l-1 passo 1 faça /* para cada curso */ 
início 
 /* Cálculo da média */ 
 soma ← 0; /* para a sumarização das notas do curso i */ 
 para j ← 0 até c-1 passo 1 faça 
 soma ← soma + nota[i][j]; 
 media← soma/c; /* média das notas do curso i */ 
 escreva(“Media = ”, media); 
 /* Cálculo do desvio */ 
 para j ← 0 até c-1 passo 1 faça 
 início 
 5 
desvio ← nota[i][j] – media; 
escreva(“Desvio da nota ”, nota[i][j], desvio); 
 fim 
 fim 
fim 
 
Em C ainda é possível dar um nome ao número máximo de linhas e de colunas da 
matriz por meio de #define, sendo que se for necessário modificar o número máximo de 
linhas e de colunas da matriz, basta alterar o valor que estiver definido no #define. 
#include <stdio.h> 
 
 #define MAXL 5 /* define o número máximo de linhas como MAXL */ 
#define MAXC 50 /* define o número máximo de colunas como MAXC */ 
 
main() 
{ 
 float soma, media, desvio, nota[MAXL][MAXC] /* matriz de notas */; 
 int l, c, i, j /* índices da matriz */; 
 /* Entrada da quantidade de cursos e de notas e verificação dos 
 limites da matriz */ 
 do { 
printf(“\nDigite o número de cursos (entre 1 e %d) e o número 
de notas (entre 1 e %d): ”, MAXL, MAXC); 
 scanf(“%d”, &l); 
 scanf(“%d”, &c); 
 if(l > MAXL || l <= 0 || c > MAXC || c <= 0) 
 printf(“Quantidade inválida”); 
 } while(l > MAXL || l <= 0 || c > MAXC || c <= 0); 
 /* Obtendo as notas para cada curso */ 
 for(i = 0; i < l; i++) /* para cada curso */ 
 { 
 printf(“Notas do curso %d:\n”, i); 
 for(j = 0; j < c; j++) /* lê as notas */ 
 { 
 printf(“Digite uma nota: ”); 
 scanf(“%f”, &nota[i][j]); 
 } 
 } 
 /* Cálculo das médias e desvios para cada curso */ 
 for(i = 0; i < l; i++) /* para cada curso */ 
 { 
/* Cálculo da média */ 
 soma = 0; /* para a sumarização das notas do curso i */ 
for(j = 0; j < c; j++) 
 soma = soma + nota[i][j]; 
 media = soma/c; /* média das notas do curso i */ 
 printf(“\nMedia = %f”, media); 
 /* Cálculo do desvio */ 
 for(j = 0; j < c; j++) 
 { 
 desvio = nota[i][j] – media; 
 printf(“\nDesvio da nota %f = %f”, nota[i][j], desvio); 
 } 
 } 
} 
 6 
4 Exemplos de Programas 
1) Faça um algoritmo e programa C que calcula o produto de duas matrizes A e B, se 
possível. A multiplicação de duas matrizes A e B só é possível se o número de colunas 
da matriz A for igual ao número de linhas da matriz B. Assim, se A é uma matriz m x 
n e B uma matriz n x p, a multiplicação será possível e o produto será uma matriz C, 
m x p. 
Solução: 
Entrada: matriz A, 2 x 3 e a matriz B, 3 x 2; 
Processo: 
 
A = 
a00 a01 ... a0n-1 
a10 a11 ... a1n-1 
... 
am-10 am-11 ... am-1n-1 m x n 
B = 
n x p 
C = 
m x p 
A matriz produto C é dada por: 
Onde: 
c00 = a00 * b00 + a01 * b10 + ... + a0n-1* bn-10 
c01 = a00 * b01 + a01 * b11 + ... + a0n-1* bn-11 
... 
c0p-1 = a00 * b0p-1+ a01 * b1p-1 + ... + a0n-1* bn-1p-1 
 
c10 = a10 * b00 + a11 * b10 + ... + a1n-1* bn-10 
c11 = a10 * b01 + a11 * b11 + ... + a1n-1* bn-11 
... 
c1p-1 = a10 * b0p-1+ a11 * b1p-1 + ... + a1n-1* bn-1p-1 
 
cm-10 = am-10 * b00 + am-11 * b10 + ... + am-1n-1* bn-10 
cm-11 = am-10 * b01 + am-11 * b11 + ... + am-1n-1* bn-11 
... 
cm-1p-1 = am-10 * b1p+ am-11 * b1p-1 + ... + am-1n-1* bn-1p-1 
 
Portanto, 
cij = ∑∑∑∑k = 0,...,n-1 aik * bkj 
b00 b01 ... b0p-1 
b10 b11 ... b1p-1 
... 
bn-10 bn-11 ... bn-1p-1 
c00 c01 ... c0p-1 
c10 c11 ... c1p-1 
... 
cm-10 cm-11 ... cm-1p-1 
Exemplo: 
1 2 3 
4 5 6 A = 2 x 3 
1 4 
2 5 
3 6 
B = 
3 x 2 
14 32 
32 77 C = produto:
2 x 2 
 
Saída: matriz C, 2 x 2 
 
Algoritmo 
início 
/* Declaração de variáveis */ 
 declare A[2][3], B[3][2], C[2][2], i, j, k: numérico inteiro; 
 /* Entrada de dados */ 
escreva(“Carregando a matriz A:”); 
para i ← 0 até 1 passo 1 faça /* linhas de A */ 
 7 
 para j ← 0 até 2 passo 1 faça /* colunas de A */ 
 início 
 escreva(“A[”, i, “,”, j, “]=”); 
 leia(A[i][j]); 
 fim 
escreva(“Carregando a matriz B:“); 
para i ← 0 até 2 passo 1 faça /* linhas de B */ 
 para j ← 0 até 1 passo 1 faça /* colunas de B */ 
 início 
 escreva(“B[”, i, “,”, j, “]=”); 
 leia(B[i][j]); 
 fim 
/* Cálculo da matriz produto C */ 
para i ← 0 até 1 passo 1 faça /* linhas de C = linhas de A */ 
 para j ← 0 até 1 passo 1 faça /* colunas de C = colunas de B */ 
 início 
 C[i][j] ← 0; 
 para k ← 0 até 2 passo 1 faça /* colunas de A = linhas de B */ 
 C[i][j] ← C[i][j] + A[i][ k] * B[k][j]; 
 fim 
/* Saída */ 
escreva(“Matriz produto C:”); 
para i ← 0 até 1 passo 1 faça /* linhas de C */ 
início 
 escreva(“linha = ”, i); 
 para j ← 0 até 1 passo 1 faça /* colunas de C */ 
 escreva(C[i][j]); 
fim 
fim 
 
#include <stdio.h> 
 
#define M 2 /* linhas de A e linhas de C*/ 
#define N 3 /* colunas de A e linhas de B */ 
#define P 2 /* colunas de B e colunas de C*/ 
 
main() 
{ 
/* Declaração de variáveis */ 
 int A[M][N], B[N][P], C[M][P], i, j, k; 
 /* Entrada de dados */ 
printf(“Carregando a matriz A:\n”); 
for(i = 0; i < M; i++) /* linhas de A */ 
 for(j = 0; j < N; j++) /* colunas de A */ 
 { 
 printf(“A[%d,%d] = “, i, j); 
 scanf(“%d”, &A[i][j]); 
 } 
printf(“Carregando a matriz B:\n“); 
for(i = 0; i < N; i++) /* linhas de B */ 
 for(j = 0; j < P; j++) /* colunas de B */ 
 { 
 printf(“B[%d,%d] = “, i, j); 
 scanf(“%d”, &B[i][j]); 
 } 
/* Cálculo da matriz produto C */ 
for(i = 0; i < M; i++) /* linhas de C = linhas de A */ 
 for(j = 0; j < P; j++) /* colunas de C = colunas de B */ 
 { 
 C[i][j] = 0; 
 8 
 for(k = 0; k < N; k++) /* colunas de A = linhas de B */ 
 C[i][j] = C[i][j] + A[i][ k] * B[k][j]; 
 } 
/* Saída */ 
printf(“Matriz produto C:”); 
for (i = 0; i < M; i++) /* linhas de C */ 
{ 
 printf(“\n”); 
 for(j = 0; j < P; j++) /* colunas de C */ 
 printf(“%d ”, C[i][j]); 
} 
} 
 
2) Uma matriz X de N (N ≤ 150) linhas por 2 colunas contém, na primeira coluna, o 
número de matrícula de N alunos e, na segunda coluna, a nota dos N alunos. Faça um 
algoritmo e programa C que: 
• leia a quantidade N de alunos; 
• leia as informações dos N alunos carregando a matriz X; 
• leia um determinado número de matrícula e determine a nota do aluno correspondente, 
repetindo o processo até que o usuário deseje parar. 
Solução: 
Entrada: número N de alunos e informações sobre os alunos a serem carregadas na 
matriz X; 
Processo e Saída: consulta a notas de alunos a partir do número da matrícula. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare N, i, achou: numérico inteiro; 
 X[150][2], mat: numérico real; 
 resp: caractere; 
 /* Entrada de dados */ 
repita 
escreva(“Digite a quantidade de alunos (entre 1 e 150): ”); 
 leia(N); 
 se (N > 150 ou N ≤ 0) 
 então escreva(“Quantidade de alunos inválida”); 
 até (N > 0 e N ≤ 150); 
para i ← 0 até N-1 passo 1 faça 
início 
 escreva(“Digite o número da matrícula do aluno: ”); 
 leia(X[i][0]); 
 escreva(“Digite a nota do aluno: ”); 
 leia(X[i][1]); 
 fim 
 /* Processo e Saída */ 
 repita 
 /* Lê a matrícula do aluno para consulta */ 
 escreva(“Entre com a matrícula do aluno para consulta: ”); 
 leia(mat); 
 /* Percorre as linhas da matriz X, procurando pela matrícula na 
primeira coluna e obtendo a nota na segunda coluna */ 
 achou ← 0; /* não achou */ 
 i ← 0; 
 enquanto (i < N e achou = 0) faça 
 início 
 se (X[i][0] = mat) 
 então início 
 9 
 achou ← 1; /* achou */ 
 escreva(“Nota = ”, X[i][1]); 
fim 
 i ← i + 1; 
 fim 
 /* Verifica se a matrícula não foi encontrada */ 
 se (achou = 0) /* não achou */ 
 então escreva(“Matricula não encontrada”); 
 /* Permite que o usuário faça mais uma consulta se desejar */ 
 escreva(“Deseja consultar mais um aluno? (S/N)”); 
 leia(resp); 
 até (resp = ‘N’); 
fim 
 
#include <stdio.h> 
#include <ctype.h> 
#include <conio.h>#define MAXL 150 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int N, i, achou; 
 float X[MAXL][2], mat; 
 char resp; 
 /* Entrada de dados */ 
do { 
printf(“Digite a quantidade de alunos (entre 1 e %d): ”, MAXL); 
 scanf(“%d”, &N); 
 if(N > MAXL || N <= 0) 
 printf(“Quantidade de alunos inválida\n”); 
 } while (N > MAXL || N <= 0); 
for(i = 0; i < N; i++) 
{ 
 printf(“Digite o número da matrícula do aluno: ”); 
 scanf(“%f”, &X[i][0]); 
 printf(“Digite a nota do aluno: ”); 
 scanf(“%f”, &X[i][1]); 
 } 
 /* Processo e Saída */ 
 do { 
 /* Lê a matrícula do aluno para consulta */ 
 printf(“\nEntre com a matrícula do aluno para consulta: ”); 
 scanf(“%f”, &mat); 
 /* Percorre as linhas da matriz X, procurando pela matrícula na 
primeira coluna e obtendo a nota na segunda coluna */ 
 achou = 0; /* não achou */ 
 i = 0; 
 while (i < N && achou == 0) 
 { 
 if (X[i][0] == mat) 
 { 
achou = 1; /* achou */ 
printf(“Nota = %f”, X[i][1]); 
 } 
 i = i + 1; 
 } 
 /* Verifica se a matrícula não foi encontrada */ 
 if (achou == 0) /* não achou */ 
 printf(“\nMatricula não encontrada”); 
 10 
 /* Permite que o usuário faça mais uma consulta se desejar */ 
 printf(“\nDeseja consultar mais um aluno? (S/N)”); 
 resp = getche(); 
} while (toupper(resp) == ‘S’); 
} 
5 Exercícios de Fixação 
1) A matriz X de N linhas (N ≤ 100) por 4 colunas, contém informações sobre alunos de 
uma Universidade. Os elementos da primeira, segunda, terceira e quarta colunas são, 
respectivamente, o número de matrícula, sexo (0 ou 1), número do curso e a média 
geral no curso. Fazer um algoritmo e programa C que: 
• leia o número N de alunos; 
• leia as informações sobre os alunos; 
• leia um determinado sexo e número de curso e determine o número da matrícula do 
aluno do sexo e curso lidos, que obteve a melhor (maior) média. 
 
2) Escrever um algoritmo e programa C que leia uma matriz 7x7 de números inteiros, 
calcule e escreva: 
• o somatório dos elementos da diagonal principal dessa matriz; 
• o produto dos elementos da diagonal principal dessa matriz; 
• a matriz após multiplicar os elementos de sua diagonal principal por uma constante K. 
 
Exemplo: 
 
 
 
 
 
 
 
 
 
3) Dada uma matriz M x N (M ≤ 20, N ≤ 50) de números reais, fazer um algoritmo e 
programa C para calcular e imprimir a soma de cada linha e a soma de todos os seus 
elementos. 
 
4) Fazer um algoritmo e programa C que leia uma matriz de números inteiros A, M x N 
(M ≤ 20, N ≤ 50), e determine a matriz transposta de A. 
Exemplo: 
 
A 0 1 2 Transposta 
de A 
0 1 
0 9 16 34 0 9 32 
1 32 11 17 1 16 11 
 2 34 17 
 
5) Dadas duas matrizes A e B, M x N (M ≤ 10, N ≤ 20) de números reais, escrever um 
algoritmo e programa C que calcule e imprima a matriz C, sendo que C = A + B. 
Elementos da diagonal 
principal da matriz.