数据结构-数组-对称矩阵与稀疏矩阵的压缩-散装C语言

关于矩阵压缩

1. 对称矩阵，只需要存储上三角或者下三角的元素，从二维的数组变为一位的数组，可以减少空间。
2. 稀疏矩阵，只有少部分的元素是有效的值，所以只需要用一个三元组，分别存储其横纵位置以及值即可。

附上截图

附上代码

#include <stdio.h>
#include <stdlib.h>
#define M_LEN 3
#define SPARSE_NUM 2

void compres_sysmetric_matrix(int (*matrix)[M_LEN]) // 压缩对称矩阵
{
    int i;
    int j;
    int k = 0;
    const int len = (M_LEN+1)/2*M_LEN;
    int csm[len] = {0}; // 初始化 
    for (i = 0; i< M_LEN; i++)
    {
        for (j = 0; j <= i; j++)
        {
            // csm[k++] = *(matrix + i*M_LEN + j);
            csm[k++] = matrix[i][j];
        }
    }
    printf("压缩后，矩阵：\n");
    for (i = 0; i < len; i++)
    {
        printf("%d ", csm[i]);
    }
    printf("\n");
}

typedef struct Triple // 三元组表示 非0 矩阵
{
    int i,j; // i,j行列 位置
    int data; // 数据值
}Tripe;


// 显示 压缩稀疏矩阵
void compres_sparse_matrix(int (*sprase_matrix)[M_LEN], Tripe *tripe) 
{
    int i, j, k, mod;
    for (i = 0; i < M_LEN; i++) // 遍历行
    {
        for (j = 0; j < M_LEN ; j++) // 遍历列
        {
            mod = 0; // 中间变量 用于 判断 此座标 是否有效 0无效 1有效
            for (k = 0; k < SPARSE_NUM; k++) // 遍历有效数值
            {
                if (i == tripe[k].i && j == tripe[k].j)
                {   
                    printf("%d ", tripe[k].data);
                    mod = 1;
                }
            }
            if (mod == 0)
            {   
                printf("%d ", sprase_matrix[i][j]);
            }
        }
        printf("\n");
    }
}


int main()
{
    // 对称矩阵
    int sysmetric_matrix[M_LEN][M_LEN] = 
    {{1, 2, 3},
     {2, 4, 5},
     {3, 5, 6}};

    // 压缩矩阵
    compres_sysmetric_matrix(sysmetric_matrix);

    // 稀疏矩阵
    int sprase_matrix[M_LEN][M_LEN] = {0}; // 3*3矩阵

    Tripe tripe[SPARSE_NUM]; // 2个稀疏值
    tripe[0].i = 0;
    tripe[0].j = 0;
    tripe[0].data = 6;

    tripe[1].i = 1;
    tripe[1].j = 1;
    tripe[1].data = 8;

    printf("显示稀疏矩阵\n");
    compres_sparse_matrix(sprase_matrix, tripe);

    system("pause");
    return 0;
}