c Dúvida em C (MATRIZ ESPARSA IMPLEMENTAÇÃO)

Wellyngton Matheus · Junho 30, 2017

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

#include <stdio.h>
#include <stdlib.h>
#include "matriz.h"

void main(void){
    TMatriz *A, *B, *C;
    LeMatriz(&A, "A.txt");
    ImprimeMatriz(&A);
    LeMatriz(&B, "B.txt");
    ImprimeMatriz(&B);
    C = SomaMatriz(A,B);
    ImprimeMatriz(&C);
    ApagaMatriz(B);
    ApagaMatriz(C);
    LeMatriz(&B,"B.txt");
    ImprimeMatriz(&A);
    ImprimeMatriz(&B);
    C = SomaMatriz(A,B);
    ImprimeMatriz(&C);
    C = MultiplicaMatriz(A,B);
    ImprimeMatriz(C);
    C = MultiplicaMatriz(B,B);
    ImprimeMatriz(A);
    ImprimeMatriz(B);
    ImprimeMatriz(C);
    ApagaMatriz(A);
    ApagaMatriz(B);
    ApagaMatriz(C);
}

matriz.c

#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.

Entrar

c Dúvida em C (MATRIZ ESPARSA IMPLEMENTAÇÃO)

Pergunta

Wellyngton Matheus

Link para o comentário

Compartilhar em outros sites

0 respostass a esta questão

Posts Recomendados

Participe da discussão

Estatísticas dos Fóruns

Navegação

Atividades