#include <stdio.h>
#include <stdlib.h>
#define TAM_BUFFER 255
#include "matriz.h"
TMatriz *criaMatriz(int m, int n){
TMatriz *A;
A = (TMatriz*)malloc(sizeof(TMatriz));
if(!A || m<=0 || n<=0){
return 0;
}
A ->inicio = NULL;
A ->fimLinha = NULL;
A ->fimColuna = NULL;
A ->m = m;
A ->n = n;
iniciaCabecas(A);
return A;
}
int iniciaCabecas(TMatriz *A){
int i=0;
T_Celula *cabeca;
cabeca = (T_Celula*)malloc(sizeof(T_Celula));
if(!cabeca){
return 0;
}
cabeca->coluna = -1;
cabeca->linha = -1;
A->inicio = cabeca;
A->fimLinha = cabeca;
A->fimColuna = cabeca;
for(i = 1; i <= A->n; i++){
cabecaColuna(A);
}
for(i = 1; i <= A->m; i++){
cabecaLinha(A);
}
return 1;
}
int cabecaColuna(TMatriz *A){
T_Celula *cabeca;
cabeca = (T_Celula*)malloc(sizeof(T_Celula));
if(!cabeca){
return 0;
}
cabeca->coluna = -1;
cabeca->linha = 0;
A->fimColuna->direita = cabeca;
A->fimColuna = cabeca;
cabeca->direita = A->inicio;
cabeca->abaixo = cabeca;
return 1;
}
int cabecaLinha(TMatriz *A){
T_Celula *cabeca;
cabeca = (T_Celula*)malloc(sizeof(T_Celula));
if(!cabeca){
return 0;
}
cabeca->coluna = 0;
cabeca->linha = -1;
A->fimLinha->abaixo = cabeca;
A->fimLinha = cabeca;
cabeca->abaixo = A->inicio;
cabeca->direita = cabeca;
return 1;
}
void ImprimeMatriz(TMatriz* A){
int i, j;
T_Celula *pCelula;
if(!A || !A->m || !A->n){
return 0;
}
pCelula = A->inicio->abaixo;
printf("\n");
for(i = 1; i <= A->m; i++){
for(j = 1; j <= A->n; j++){
if(pCelula->direita->linha == i && pCelula->direita->coluna == j){
printf(" \t%0.2f ", pCelula->valor);
}
else{
printf(" \t%0.2f ", 0.0F);
}
}
printf("\n");
pCelula = pCelula->direita->abaixo;
}
return 1;
}
void LeMatriz(TMatriz* A, char fn[]){
FILE* f;
int m, n;
f = fopen(fn, "r");
fscanf(f, "%d,%d ", &m, &n);
A = criaMatriz(m, n);
int i, j;
double valor;
while(fscanf(f, "%d, %d, %lf", &i, &j, &valor)!= EOF){
insere(A, i, j, valor);
}
fclose(f);
}
void ApagaMatriz(TMatriz* A){
int i = 1;
int j = 1;
T_Celula *pCelula, *aux;
if(!A || !A->m || !A->n){
return 0;
}
pCelula = A->inicio->abaixo;
pCelula = pCelula->direita;
for(i = 1; i <= A->m; i++){
for(j = 1; j<= A->n; j++){
if(pCelula->linha == i && pCelula->coluna == j){
aux = pCelula;
pCelula = pCelula->direita;
free(aux);
}
}
pCelula = pCelula->abaixo->direita;
}
pCelula = A->inicio->direita;
for(i = 0; i < A->n; i++){
aux = pCelula;
pCelula = pCelula->direita;
free(aux);
}
pCelula = A->inicio->abaixo;
for(i = 0; i < A->m; i++){
aux = pCelula;
pCelula = pCelula->abaixo;
free(aux);
}
pCelula = A->inicio;
free(pCelula);
A->fimColuna = A->fimLinha = A->inicio = NULL;
A->m = A->n = 0;
A = NULL;
return 1;
}
TMatriz *SomaMatriz(TMatriz* A, TMatriz* B){
int i, j;
float soma;
TMatriz *C;
T_Celula *pCelulaA, *pCelulaB;
if(A->m != B->m || A->n != B->n){
printf("\nMatrizes de ordem diferente.\nSo e possivel somar matrizes com o mesmo numero de linhas e colunas\n");
return NULL;
}
if(!A || !B || !A->m || !A->n){
return NULL;
}
C = criaMatriz(A->m, B->n);
pCelulaA = A->inicio->abaixo;
pCelulaB = B->inicio->abaixo;
for(i = 1; i<= A->m; i++){
for(i = 1; j<= B->n; i++){
if(j == pCelulaA->direita->coluna && j == pCelulaB->direita->coluna){
soma = pCelulaA->direita->valor + pCelulaB->direita->valor;
if(soma){
insere(C, i, j, soma);
}
pCelulaA = pCelulaA->direita;
pCelulaB = pCelulaB->direita;
}
else if(j == pCelulaA->direita->coluna){
insere(C, i, j, pCelulaA->direita->valor);
pCelulaA = pCelulaA->direita;
}
else if( j == pCelulaB->direita->coluna){
insere(C, i, j, pCelulaB->direita->valor);
pCelulaB = pCelulaB->direita;
}
}
pCelulaA = pCelulaA->direita->abaixo;
pCelulaB = pCelulaB->direita->abaixo;
}
return C;
}
TMatriz *MultiplicaMatriz(TMatriz* A, TMatriz* B){
int i=0, j=0, k=0;
float total;
TMatriz *C;
if(A->n != B->m){
printf("\nMultiplicacao não efetuada, numero de colunas de A e diferente do numero de linhas de B\n");
return NULL;
}
if(!A || !B || !A->m || !A->n || !B->n){
return NULL;
}
C = criaMatriz(A->m, B->n);
for(i = 1; i<= A->m; i++){
for(j = 1; j<= B->n; j++){
total = 0;
for(k = 1; k<= A->n; k++){
total += obterEI(A, i, k) *obterEI(B, k, j);
}
if(total){
insere(C, i, j, total);
}
}
}
return C;
}
int insere(TMatriz *A, int linha, int coluna, double valor){
int i;
if (!A || A->m <= 0 || A->n <= 0 || !valor){
return 0;
}
if (linha>A->m || coluna>A->n || !valor || linha < 1 || coluna < 1){
return 0;
}
T_Celula *pCelula;
T_Celula *pCelulaColuna;
T_Celula *pCelulaLinha;
pCelula = (T_Celula*)malloc(sizeof(T_Celula));
if(!pCelula){ //memoria cheia
return 0;
}
for(i = 0; i<linha-1; i++){
pCelulaLinha=pCelulaLinha->abaixo;
}
i = 0;
while(i<coluna && pCelulaLinha->direita->linha != -1){
if(pCelulaColuna->direita->coluna > pCelula->coluna){
pCelula->direita = pCelulaLinha->direita;
}
else{
pCelulaLinha = pCelulaLinha->direita;
}
i++;
}
if(pCelulaLinha->direita->linha == -1){
pCelula->direita = pCelulaLinha->direita;
pCelulaLinha->direita = pCelula;
}
for(i = 0; i< coluna-1; i++){
pCelulaColuna = pCelulaColuna->direita;
}
i = 0;
while(i<linha && pCelulaColuna->abaixo->coluna != -1){
if(pCelulaColuna->abaixo->linha > pCelula->linha){
pCelula->abaixo = pCelulaColuna->abaixo;
pCelulaColuna->abaixo = pCelula;
}
else{
pCelulaColuna = pCelulaColuna->abaixo;
}
i++;
}
if(pCelulaColuna->abaixo->coluna == -1){
pCelula->abaixo = pCelulaColuna->abaixo;
pCelulaColuna->abaixo = pCelula;
}
return 1;
}
float obterEI(TMatriz *A, int linha, int coluna){
T_Celula *pCelula;
int i = 0;
pCelula = A->inicio->direita;
for(i = 0; i< coluna-1; i++) {
pCelula = pCelula->direita;
}
do{
pCelula = pCelula->abaixo;
if(pCelula->linha == linha){
return pCelula->valor;
}
}while(pCelula->coluna != -1);
return 0;
}
matriz.h
#include <stdio.h>
#include <stdlib.h>
typedef struct TCelula{
struct TCelula *direita, *abaixo;
int linha, coluna;
float valor;
}T_Celula;
typedef struct{
int m, n;
T_Celula *inicio, *fimLinha, *fimColuna;
}T_matrizEsparsa;
typedef T_matrizEsparsa TMatriz;
//funções
TMatriz *criaMatriz(int m, int n); //cria uma matriz esparsa vazia
int iniciaCabecas (TMatriz *A); //inicia as cabeças
int cabecaLinha (TMatriz *A); //insere uma cabeça linha
int cabecaColuna (TMatriz *A); //insere uma cabeça coluna
void ImprimeMatriz(TMatriz *A); //imorime a matriz A
void LeMatriz(TMatriz *A, char fn[]);//lê a matriz
void ApagaMatriz(TMatriz *A); //apaga uma matriz
TMatriz *SomaMatriz(TMatriz *A, TMatriz *B); //soma duas matrizes A e B, gerando um nova matriz C
TMatriz *MultiplicaMatriz(TMatriz *A, TMatriz *B); //multiplica uma matriz por uma outra, gerando uma nova matriz X
int insere(TMatriz *A, int linha, int coluna, double valor);
float obterEI(TMatriz *A, int linha, int coluna); //obter o elemento pelo seu índice
Meu programa não está rodando, gostaria de saber o que há de errado e como consertar. Desde já agradeço a ajuda e desculpe qualquer erro na postagem.
Pergunta
Wellyngton Matheus
Boa tarde pessoal, sou novo aqui e estou com dúvidas sobre a implementação de lista encadeada com matrizes esparsas. O que já fiz até agora:
main.c
matriz.c
matriz.h
Meu programa não está rodando, gostaria de saber o que há de errado e como consertar. Desde já agradeço a ajuda e desculpe qualquer erro na postagem.
Link para o comentário
Compartilhar em outros sites
0 respostass a esta questão
Posts Recomendados
Participe da discussão
Você pode postar agora e se registrar depois. Se você já tem uma conta, acesse agora para postar com sua conta.