C语言实现稀疏矩阵存储和转置

最新推荐文章于 2022-08-07 16:23:06 发布
最新推荐文章于 2022-08-07 16:23:06 发布
阅读量1.3k 收藏 9
点赞数 3
分类专栏： 算法实现 编程随笔 稀疏矩阵 文章标签： c算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37661932/article/details/110211454
版权

稀疏矩阵存储和转置

稀疏矩阵是矩阵中一种特别的矩阵，主要特点是：非零元素占矩阵所有元素的比例极少。那么，对于这种矩阵的存储，就存在很多很节省空间的方式，核心要点也就是舍弃那些无用元素即零元素，下面将以两种存储方式进行程序设计的实现：

关于稀疏矩阵的COO存储和CSR存储方式，以及不同存储方式的转置矩阵，使用C语言实现逻辑功能，稀疏矩阵二维阵列及行列长度均保存在input.bat文件中，文件见问末，详细代码如下：

使用C语言实现，通过VC++6.0开发工具实现。

// 完整代码
#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"


#define MAXSIZE 100       //最大非零元数
//COO格式 
typedef struct Triple {     //三元组
    int i, j;               //行列下标
    float e;             //非零元元素值
}Triple;
typedef struct TSMatrix {       //矩阵
    Triple data[MAXSIZE + 1];   //三元组表
    int mu, nu, tu;             //矩阵的行列数、非零元个数
}TSMatrix;

//CSR格式 
typedef struct Tuple {     //二元组
    int j;               //列下标
    float e;             //非零元元素值
}Tuple;
typedef struct Dista {     //第一个非空字符距离 
    int l;               //长度 
}Dista;
typedef struct CSRstorage {       //矩阵
    Tuple data[MAXSIZE + 1];   //二元组表,替代两个有关系的一维表
    Dista dist[MAXSIZE + 1];   //距离数组 
    int mu, nu, tu;             //矩阵的行列数、非零元个数
}CSRstorage;

void main()
{
    //声明矩阵 
    TSMatrix M,Tr;//COO
    CSRstorage Xs,XsZ;//CSR
    int i,j,t;
    //打印学生学号和姓名
    printf("学号：2019xxx\t姓名：xxx\n"); 
    //***************************************************************************
    //读取bat文件内容,并以COO格式存儲 
    //***************************************************************************
    int m,n;//长度和宽度
    float sp[15][15]; //自定义二维数组大小
    FILE *p1 = fopen("input.bat", "r");  //input.bat文件放在.c文件所在的文件夹中
    if (p1==NULL)  //检测是否成功打开
    {
        printf("Open failed\n");
    }
    //读取数组长度 
    fscanf(p1,"%d",&m);
    fscanf(p1,"%d",&n);
    M.mu = m;
    M.nu = n;
    //二维数读取矩阵值,并以COO格式存储 
    int temp = 0;
    for (i = 0; i<15; i++)
    {
        for (j = 0; j<15; j++)
        {
            fscanf(p1, "%f", &sp[i][j]);   //读入input.bat数据给数组sp
            if(!(sp[i][j]<0.000001&&sp[i][j]>-0.000001))
            {
                M.data[temp].i = i;
                M.data[temp].j = j;
                M.data[temp].e = sp[i][j];
                temp = temp + 1;
            }
        }
    }
    M.tu = temp;
    fclose(p1);//释放指针
    //***************************************************************************
    //打印三个向量，非零
    //***************************************************************************
    printf("COO,打印三个向量如下:\n");
    printf("(%d,%d,%g)\t",M.data[0].i,M.data[0].j,M.data[0].e);
    printf("(%d,%d,%g)\t",M.data[1].i,M.data[1].j,M.data[1].e);
    printf("(%d,%d,%g)\n",M.data[2].i,M.data[2].j,M.data[2].e);
    //***************************************************************************
    //打印原始矩阵 
    //***************************************************************************
    printf("COO,打印原始矩阵如下:\n"); 
    for (i = 0; i<M.mu; i++)
    {
        for (j = 0; j<M.nu; j++)
        {
            int bs = 0;
            for(t = 0;t<M.tu;t++)
            {
                if(i == M.data[t].i && j == M.data[t].j){
                    printf("%g\t",M.data[t].e);
                    bs = 1;
                    break;
                }
            }
            if(bs == 0){
                printf("0\t");
            }
        }
        putchar('\n');//每行结束换行
    }
    //***************************************************************************
    //矩阵转置
    //***************************************************************************
    Tr.mu = M.nu;
    Tr.nu = M.mu;
    Tr.tu = M.tu;
    for(t = 0;t<M.tu;t++)
    {
        Tr.data[t].i = M.data[t].j;
        Tr.data[t].j = M.data[t].i;
        Tr.data[t].e = M.data[t].e;
    }
    //***************************************************************************
    //打印转置矩阵 
    //***************************************************************************
    printf("COO,打印转置矩阵如下:\n");
    for (i = 0; i<Tr.mu; i++)
    {
        for (j = 0; j<Tr.nu; j++)
        {
            int bs = 0;
            for(t = 0;t<Tr.tu;t++)
            {
                if(i == Tr.data[t].i && j == Tr.data[t].j){
                    printf("%g\t",Tr.data[t].e);
                    bs = 1;
                    break;
                }
            }
            if(bs == 0){
                printf("0\t");
            }
        }
        putchar('\n');//每行结束换行
    }
    //***************************************************************************
    //以 CSR格式存儲 Xs
    //***************************************************************************
    Xs.mu = m;
    Xs.nu = n;
    int num = 0;
    for (i = 0; i<m; i++)
    {
        Xs.dist[i].l = num;
        for (j = 0; j<n; j++)
        {
            
            if(!(sp[i][j]<0.000001&&sp[i][j]>-0.000001))
            {
                Xs.data[num].j = j;
                Xs.data[num].e = sp[i][j];
                num = num + 1;
            }
        }
    }
    Xs.dist[m].l = num;
    Xs.tu = num;
    //***************************************************************************
    //打印三個向量 
    //***************************************************************************
    //方式一，先计算出三个，再打印
    //方式二，一直打印，累计三个
    printf("CSR,打印三个向量：\n");
    int js = 0;
    for(i=1;i<=m;i++)
    {
        if(js>=3)
        {
            break;
        }
        for(j=0;j<Xs.dist[i].l-Xs.dist[i-1].l;j++)
        {
            if(js>=3)
            {
                break;
            }
            printf("(%d,%d,%g)\t",Xs.dist[i-1].l,Xs.data[Xs.dist[i-1].l+j].j,Xs.data[Xs.dist[i-1].l+j].e);
            js = js + 1;
        }
    }
    //***************************************************************************
    //打印原始矩陣 
    //***************************************************************************
    printf("\nCSR,打印原始矩阵如下:\n"); 
    for (i = 0; i<Xs.mu; i++)
    {
        if(Xs.dist[i+1].l-Xs.dist[i].l>0)
        {
            for(j = 0; j<Xs.nu; j++)
            {
                int bs = 0;
                for(t = Xs.dist[i].l;t<Xs.dist[i+1].l;t++)
                {
                    if(j == Xs.data[t].j){
                        printf("%g\t",Xs.data[t].e);
                        bs = 1;
                        break;
                    }
                }
                if(bs == 0){
                    printf("0\t");
                }
            } 
        } else {
            for(j = 0; j<Xs.nu; j++)
            {
                printf("0\t");
            }
        }
        putchar('\n');//每行结束换行
    }
    //***************************************************************************
    //矩陣转置 XsZ
    //***************************************************************************
    XsZ.mu = Xs.nu;
    XsZ.nu = Xs.mu;
    XsZ.tu = Xs.tu;
    int Znum = 0;
    for(i=0;i<XsZ.nu;i++)
    {
        XsZ.dist[i].l = Znum;
        for(j=0;j<XsZ.tu;j++)
        {
            if(i == Xs.data[j].j)
            {
                XsZ.data[Znum].e = Xs.data[j].e; 
                for(t=0;t<Xs.mu;t++){
                    if(j>=Xs.dist[t].l&&j<=Xs.dist[t+1].l){
                        XsZ.data[Znum].j = t;
                    }
                }
                Znum = Znum + 1;
            }
        }
    }
    XsZ.dist[XsZ.nu].l = Znum;
    //***************************************************************************
    //打印转置矩阵 
    //***************************************************************************
    printf("CSR,打印转置矩阵如下:\n"); 
    for (i = 0; i<XsZ.mu; i++)
    {
        if(XsZ.dist[i+1].l-XsZ.dist[i].l>0)
        {
            for(j = 0; j<XsZ.nu; j++)
            {
                int bs = 0;
                for(t = XsZ.dist[i].l;t<XsZ.dist[i+1].l;t++)
                {
                    if(j == XsZ.data[t].j){
                        printf("%g\t",XsZ.data[t].e);
                        bs = 1;
                        break;
                    }
                }
                if(bs == 0){
                    printf("0\t");
                }
            } 
        } else {
            for(j = 0; j<Xs.nu; j++)
            {
                printf("0\t");
            }
        }
        putchar('\n');//每行结束换行
    }
    system("pause");//运行结果停留显示，不会一闪而过
}

input.bat文件内容示例如下：
下面展示一些 文本内容。

15
15
0 2.8 0 0 0 0 0 0 0 0 0 0 0 0 0
-4.3 0 0 0 0 0 0 0 0 0 0 0 0 0 0.3
0 0 0 0 0 0 8 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 3.5 0 0 0 86 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 7 0 0 0
0 0 4 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0 0 0 5 0 0
0 0 0 3 0 0 23 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 6 0 0 0 0 1.1 0 0 0
9 0 0 0 0 0 0 0 2 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 -8.52
write_you
关注
专栏目录
C语言实现稀疏矩阵
Arithmetic-logic
07-26 3124
稀疏矩阵的压缩存储：对0元不分配 定义结构体（三元组表示法） #define ElemType int typedef struct Triple {//表中每个元素都有3个分量 int i;//行下标 int j;//列下标 ElemType e;//数值 }; typedef struct SMatrix {//用于管理整个矩阵 Triple data[MAXSIZE];//矩阵中的每个元素 int mu;//矩阵的行 int nu;//矩阵的列 int tu;//矩阵的非零个数 };
用C语言实现稀疏矩阵的三元组转置
01-18
数据结构，该程序是利用c语言实现稀疏矩阵的三元组转置算法
C语言实现稀疏矩阵并转置
weixin_42948205的博客
10-22 495
// //Created by zhuoL on 2021/10/20. // #include <stdio.h> #include <stdlib.h> // 非零元最大个数 #define MAXSIZE 20 // 定义三元组 typedef struct { int i, j, e;//行 列 非零元素值 } Triple; // 定义稀疏矩阵 typedef struct { Triple data[MAXSIZE + 1]; int mu, nu
C语言实现-稀疏矩阵转置
coder-itl
10-25 1299
问题描述 输入矩阵的行数、列数和非零元素个数，以及所有非零元素，非零元素包括每个元素的行号、列号、元素值。 要求：1. 输入的非零元素个数必须满足稀疏矩阵要求，输入过程检测是否满足此要求，若不满足，则重新输入非零元素个数； 2. 非零元素按行号从小到大顺序输入，相同行号的元素，列号从小到大输入，输入过程检测是否满足此要求，若不满足，则重新输入当前非零元素的行号、列号和元素值 了解什么是稀疏矩阵 /** * 稀疏矩阵: 是指矩阵中大多数元素为 0 的矩阵。从直观
C语言实现稀疏矩阵的存储，转置，输出
03-25
本程序详细实现了稀疏矩阵的存储，转置，输出。关键步骤都作了详细的注释。
C语言实现稀疏矩阵的转置
weixin_51927215的博客
03-27 530
#include <stdio.h> #define number 10 // 结构体声明三元组节点 typedef struct { int i, j; int data; } triple; // 结构体声明稀疏矩阵节点 typedef struct { triple data[10]; int n, m, num; } TSMatrix; int index = 1; // 全局变量（记录三元组的索引值） // 输出存储的稀疏矩阵 void d
稀疏矩阵的实现及快速转置（C语言）
05-14
C语言实现稀疏矩阵创建、快速转置（数据结构），含有具体的代码注释说明，条理清晰。
数据结构——基于C语言实现稀疏矩阵的转置.rar
08-11
总结来说，这个压缩包文件提供了一个关于如何用C语言实现稀疏矩阵转置的实例，涉及到的关键技术包括数据结构（稀疏矩阵和三元组表）、一次定位快速转置算法以及C语言的指针和动态内存管理。掌握这些知识对于理解和...
C和C++实现稀疏矩阵创建、快速转置（数据结构）
05-13
总结，理解和实现稀疏矩阵的创建和快速转置是数据结构和算法学习的重要部分。通过C和C++，我们可以有效地利用内存和计算资源，解决大规模稀疏矩阵问题，这对于科学计算、图形学、网络分析等领域具有重要意义。通过...
稀疏矩阵的压缩存储
Scrutiny的博客
05-02 1853
稀疏矩阵的压缩存储： 实现稀疏矩阵压缩存储，并实现矩阵转置和求和。 输入矩阵时，首先需要输入非零元素的个数，然后分别输入矩阵的 行号，列号和值。 输完2个矩阵后，自动进行计算第一个矩阵的转置以及两个矩阵的和。 例如：输入如下： 100 90 5 //矩阵的行数为100，列数为90，共5个非零元素。 1 10 100 //a(1,10)=100 50 60 200//a(50,60)=200 50 ...
稀疏矩阵转置的c程序实现
10-26
稀疏矩阵转置的c程序实现:稀疏矩阵的大部分元素为0，该程序不保存元素0，节省了运行空间
稀疏矩阵压缩存储及快速转置_C语言_
10-04
输入三元组压缩存储稀疏矩阵并进行快速转置
稀疏矩阵快速转置C语言算法
10-21
数据结构，稀疏矩阵快速转置c语言算法，时间复杂性为O(n+t)。
c语言实现稀疏矩阵的加减乘，转置
11-19
用三元组存储稀疏矩阵，编写函数进行稀疏矩阵的基本运算
稀疏矩阵的三元组顺序表存储表示及其转置算法
11-02
//稀疏矩阵的三元组顺序表存储表示 #define MAXSIZE 100 //非零元个数最大为100 typedef struct {int i,j; //非零元的行下标和列下标 ElemType e; //非零元 }Triple; typedef struct {Triple data[MAXSIZE+1]; //非零元三元组表,data[0]不用 int mu,nu,tu; //矩阵的总行数,总列数,非零元总个数 }TSMatrix;
C语言数据结构稀疏矩阵的转置
Algorithm_Soul
06-11 1758
/* *稀疏矩阵的转置 *创建一个二维数组 *创建一个三元组数组来存放矩阵的元素 *转置矩阵存放的公式为 sum[] 数组存放每一列的非零元素的个数 *cpot[]数组存放每一列第一个非零元素在转置三元组中的位置 */ #include<stdio.h> #include<stdlib.h> #include<time.h> #define MAXSIZE 1...
稀疏矩阵转置--C语言
qq_42338744的博客
08-07 1212
数据结构 矩阵转置算法
稀疏矩阵转置（C语言）
Lucky Home
03-29 5835
最近有数据结构实验课了，还得学一学数据结构喽，以后就把学习经过贴上来了。 稀疏矩阵 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组 稀疏数组的处理方法 1）记录数组一共有几行几列，有多少个不同的值(假设有sum个，则稀疏矩阵有sum+1行，3列) 2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 百度盗图（手动滑稽） 稀疏矩阵转置 题目 （不得不说这个题输入数据的确坑。。） 有两种方法转置 话不多说，上代码： #include<stdi
稀疏矩阵转置算法（C语言）
weixin_57093836的博客
04-03 2974
（参考数据结构教材，严蔚敏，吴伟民版 p99，多谢阅读，望对您有帮助） 无论是几维的数组，在计算机中都是以一维数组的方式进行存储的。 矩阵：相当于二维数组，它的存储，依然是用一维数组的方式进行存储。 nxn的矩阵，在计算机空间上，需要nxn个空间。 稀疏矩阵的压缩：将矩阵中的值为零或者为常数C的某c个数，不做存储（或者共用同样的空间，本题转置对0不做存储），压缩后原本nxn的矩阵，存储只需要nxn-c的空间 下面以这样的M矩阵进行转置 1 2 3 4 0 0 0 5 1 转置后得N矩阵： 1 4 0 2
c语言实现 稀疏矩阵三元组转置
最新发布
10-25
下面是一个简单的C语言实现稀疏矩阵三元组转置的代码示例： ``` #include #define MAX_SIZE 100 typedef struct { int row; int col; int val; } Triple; typedef struct { int row; int col; int num; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值