Com essa atividade de programação, solicitada em meu curso de Laboratório de Estruturas de Dados e Algoritmos (CES-11), pude fortalecer a minha habilidade para pensar e implementar soluções para problemas através de caminhos recursivos; além disso, foi possível recordar as aplicações de alocação dinâmica de matrizes, quebra de problemas em funções e, por fim, operações com arquivos.
Veja, a seguir, um vídeo demonstrativo da execução de meu programa:
Segue, abaixo, todo o código produzido, "LAB1.c":
#include <stdio.h>
#include <stdlib.h>
typedef int *vetor;
typedef vetor *matriz;
int testador(matriz M, int n, int i, int j, int max){
//testa os elementos da matriz M e os compara com o maior obtido ate entao (max), retornando o maior inteiro
//n: ordem da matriz
//i e j: parametros de cada elemento da matriz (elemento M[i][j])
//percorre as linhas da esquerda para a direita:
if(i < n-1){
if(M[i][j] > max)
return testador(M, n, i+1, j, M[i][j]);
return testador(M, n, i+1, j, max);
}
//quando chega ao final de uma linha (M[i][j] = M[n-1][j]):
else if((i == n-1) && (j < n-1)){
if(M[i][j] > max)
return testador (M, n, 0, j+1, M[i][j]);
return testador (M, n, 0, j+1, max);
}
//quando chega ao final da matriz (M[i][j] = M[n-1][n-1]):
else{
if(M[i][j] > max)
return M[i][j];
else
return max;
}
}//func. testador()
int retornarMaiorElemento(matriz M, int n){
int max = M[0][0];
//os parametros i e j da func. testador comecam zerados
return testador (M, n, 0, 0, max);
}//FUNC. retornarMaiorElemento()
void DeixarMatrizPronta(matriz A, int n, int i){
//A FUNC. alocarMatriz() aloca o vetor de ponteiros, que eh apontado por **A;
//A func. DeixarMatrizPronta() alocara, entao, a matriz em si, apontada pelos ponteiros do vetor:
if (i <= n-1){
A[i] = (int *) malloc (n * sizeof (int));
DeixarMatrizPronta (A, n, i+1);
}
}//func. DeixarMatrizPronta()
matriz alocarMatriz(int n){
matriz A;
A = (vetor *) malloc (n * sizeof (vetor));
DeixarMatrizPronta (A, n, 0);
return A;
}//FUNC. alocarMatriz()
void desalocacao(matriz A, int n, int i){
//desalocara as linhas da matriz, comecando pela ultima
if (i >= 0){
free(A[i]);
desalocacao(A, n, i-1);
}
}//func. desalocacao()
void desalocarMatriz(matriz A, int n){
//desalocara o vetor de ponteiros
desalocacao (A, n, n-1);
free(A);
}//FUNC. desalocarMatriz()
void transpor (matriz M, matriz A, int n, int i, int j){
A[j][i] = M[i][j];
if (i < n-1)
i++;
else if((i == n-1) && (j < n-1)){
i = 0;
j++;
}
else if((i == n-1) && (j==n-1))
return;
transpor(M, A, n, i, j);
}//func. transpor()
matriz criarTransposta(matriz M, int n){
matriz T;
T = alocarMatriz (n);
transpor(M, T, n, 0, 0);
return T;
}//FUNC. criarTransposta()
void ZerarMatriz(matriz A, int i, int j, int n){
//func. com o objetivo de zerar a matriz A para poder receber o produto das matrizes M1 e M2
A[i][j] = 0;
if(i < n-1)
i++;
else if((i == n-1) && (j < n-1)){
i = 0;
j++;
}
else if((i == n-1) && (j == n-1))
return;
ZerarMatriz(A, i, j, n);
}//func. ZerarMatriz()
void efetuarProduto(matriz P, matriz M1, matriz M2, int i, int j, int k, int n){
//O algoritmo segue o procedimento escrito como nos somatorios:
P[i][k] += M1[i][j] * M2[j][k];
if(j < n-1)
j++;
else if((j == n-1) && (k < n-1)){
j = 0;
k++;
}
else if((j == n-1) && (k == n-1) && (i < n-1)){
j = 0;
k = 0;
i++;
}
else if((j == n-1) && (k == n-1) && (i == n-1)){
return;
}
efetuarProduto (P, M1, M2, i, j, k, n);
}//func. efetuarProduto()
matriz calcularProduto(matriz M1, matriz M2, int n){
matriz P;
P = alocarMatriz(n);
ZerarMatriz(P, 0, 0, n);
efetuarProduto(P, M1, M2, 0, 0, 0, n);
return P;
}//FUNC. calcularProduto()
void preencherMatriz(matriz X, matriz M, int j, int p, int q, int n){
//preenche X com os valores de M tirando-se a linha 0 e a coluna j (da Regra de Laplace)
if(p > 0){
if(q < j)
X[p-1][q] = M [p][q];
else if(q > j)
X[p-1][q-1] = M[p][q];
}
if(p < n-1)
preencherMatriz(X, M, j, p+1, q, n);
else if((p == n-1) && (q < n-1))
preencherMatriz(X, M, j, 0, q+1, n);
else if((p == n-1) && (q == n-1))
return;
}//func. preencherMatriz()
int calcularDeterminante (matriz M, int n){
//Regra de Laplace
if(n==1)
return M[0][0];
else{
int j, Det = 0, cofator;
matriz X;
X = alocarMatriz(n-1);
for(j=0; j <= n-1; j++){
//preencherMatriz eh a func. que torna X o Menor Complementar de A, de indices 0 e j:
preencherMatriz(X, M, j, 0, 0, n);
//O cofator eh definido pelo produto do det. do Menor Complementar (Det X) por (-1)^(0+j):
if (j%2 == 0)
cofator = calcularDeterminante(X, n-1);
else if (j%2 == 1)
cofator = (-1) * calcularDeterminante(X, n-1);
Det += M[0][j] * cofator;
}
desalocarMatriz(X, n-1);
return Det;
}
}//FUNC. calcularDeterminante()
int main(){
FILE *f1, *f2;
f1 = fopen("entrada.txt", "r");/*O arquivo "entrada.txt" sera criado pelo programa "Gerar matrizes pseudo-aleatorias.exe"*/
f2 = fopen("saida.txt", "w");
int i, j, k, Operacao, Ordem, Quantidade_de_operacoes;
fscanf(f1, "%d", &Quantidade_de_operacoes);
for(i=1; i<=Quantidade_de_operacoes; i++){
fscanf(f1, "%d", &Operacao);
fscanf(f1, "%d", &Ordem);
switch(Operacao){
case 1:{//FUNC. retornarMaiorElemento()
matriz A;
A = alocarMatriz(Ordem);
for(j=0; j< Ordem; j++)
for(k=0; k< Ordem; k++)
fscanf(f1, " %d", &A[j][k]);
fprintf(f2, "%3d\n\n",retornarMaiorElemento(A, Ordem));/*ja imprime direto o valor da FUNC.*/
desalocarMatriz(A, Ordem);
}break;
case 2:{//FUNC. criarTransposta()
matriz A, T;
A = alocarMatriz(Ordem);
for(j=0; j< Ordem; j++)
for(k=0; k< Ordem; k++)
fscanf(f1, "%d", &A[j][k]);
T = criarTransposta(A, Ordem);/*T recebe os valores de At*/
for(j=0; j < Ordem; j++){
for(k=0; k<Ordem; k++)
fprintf(f2, "%3d", T[j][k]);
fprintf(f2, "\n");
}
fprintf(f2, "\n");
desalocarMatriz(A, Ordem);
desalocarMatriz(T, Ordem);
}break;
case 3:{//FUNC. calcularProduto()
matriz A, B, P;
A = alocarMatriz(Ordem);
B = alocarMatriz(Ordem);
for(j=0; j< Ordem; j++)
for(k=0; k< Ordem; k++)
fscanf(f1, "%d", &A[j][k]);
for(j=0; j< Ordem; j++)
for(k=0; k< Ordem; k++)
fscanf(f1, "%d", &B[j][k]);
P = calcularProduto(A, B, Ordem);/*OBS: a FUNC. ja aloca espaco para P*/
for(j=0; j < Ordem; j++)
{
for(k=0; k<Ordem; k++)
fprintf(f2, "%6d", P[j][k]);
fprintf(f2, "\n");
}
fprintf(f2, "\n");
desalocarMatriz(A, Ordem);
desalocarMatriz(B, Ordem);
desalocarMatriz(P, Ordem);
}break;
case 4:{//FUNC. calcularDeterminante
matriz A;
A = alocarMatriz(Ordem);
for(j = 0; j < Ordem; j++)
for(k = 0; k < Ordem; k++)
fscanf(f1, "%d", &A[j][k]);
fprintf(f2, " %d\n\n", calcularDeterminante(A, Ordem));/*ja imprime direto o valor da FUNC.*/
desalocarMatriz(A, Ordem);
}break;
}
}
fclose(f1);
fclose(f2);
return 0;
}
Nenhum comentário:
Postar um comentário