三元组表示的稀疏矩阵的相加

本文介绍了如何使用C++定义稀疏矩阵类,包括压缩表示法的`TSMatrix`,并展示了矩阵初始化、显示完整和压缩形式的方法。核心内容是`add`函数实现矩阵相加,通过实例演示了矩阵`T1`和`T2`的加法运算。

#include<iostream>
using namespace std;
const int Max=100;
const int Max_rows=4;
const int Max_cols=7;
   typedef class
        {
            public :
            int r;
            int c;
            int e;
        }TupNode;

    typedef class
        {
            public :
                int rows;
                int cols;
                int nums;
                TupNode date[Max];
        }TSMatrix;
    void display(TSMatrix &m); //输出压缩后的稀疏矩阵
    void show(TSMatrix &m);//输出完整的稀疏矩阵
    void init_matrix(TSMatrix &m,int r,int c,int a[][Max_cols]);//矩阵的初始化
    void add(TSMatrix m1,TSMatrix m2,TSMatrix &m3);
    int main()
        {
            int a1[Max_rows][Max_cols]=
            {
                {0,8,0,6,0,2,0},
                {0,0,34,54,0,0,2},
                {-7,0,0,0,0,0,0},
                {0,0,0,0,-12,0,0}

            };
            TSMatrix t1,t2,t3;
            init_matrix(t1,Max_rows,Max_cols,a1);
            show(t1);
            display(t1);
            cout<<endl;

            int a2[Max_rows][Max_cols]=
                {
                    {0,0,24,2,0,2,0 },
                    {0,8,0,7,14,2,0 },
                    {0,0,0,0,0,2,0  },
                    {0,-13,0,6,0,2,0},
                };
             init_matrix(t2,Max_rows,Max_cols,a2);
             show(t2);
             display(t2);
             add(t1,t2,t3);
             show(t3);
             display(t3);
            return 0;

        }


    void show(TSMatrix &m)//输出完整的稀疏矩阵
        {
            int i,j,k=0;
           for(i=0;i<m.rows;i++)
           {
               for(j=0;j<m.cols;j++)
               {
                   if(m.date[k].r==i&&m.date[k].c==j)
                   {
                       cout<<m.date[k].e<<"   ";
                       k++;
                   }

                   else
                   {
                      cout<<0<<"   ";
                   }
               }

               cout<<endl;
           }

           cout<<endl;

        }

        void display(TSMatrix &m) //输出压缩后的稀疏矩阵
            {
                int i;
                for(i=0;i<m.nums;i++)
                {
                    cout<<m.date[i].e<<" ";
                }

                cout<<endl;
            }

        void init_matrix(TSMatrix &m,int r,int c,int a[][Max_cols])//矩阵的初始化
            {
                    int i,j,counts=0;
                    for(i=0;i<r;i++)
                    {
                        for(j=0;j<c;j++)
                        {
                            if(a[i][j]!=0)
                            {
                                m.date[counts].r=i;
                                m.date[counts].c=j;
                                m.date[counts].e=a[i][j];
                                counts++;
                            }
                        }
                    }
                    m.nums=counts;
                    m.rows=r;
                    m.cols=c;
            }

        void add(TSMatrix m1,TSMatrix m2,TSMatrix &m3)
            {
                int i=0,j=0,nums=0;
                while(i<m1.nums&&j<m2.nums)
                {
                    if(m1.date[i].r==m2.date[j].r)
                    {
                        if(m1.date[i].c<m2.date[j].c)
                        {
                            m3.date[nums].c=m1.date[i].c;
                            m3.date[nums].r=m1.date[i].r;
                            m3.date[nums].e=m1.date[i].e;
                            nums++;
                            i++;
                        }

                        else if(m1.date[i].c>m2.date[j].c)
                        {
                            m3.date[nums].c=m2.date[j].c;
                            m3.date[nums].r=m2.date[j].r;
                            m3.date[nums].e=m2.date[j].e;
                            j++;
                            nums++;

                        }

                        else
                        {
                            if(m1.date[i].e+m2.date[j].e!=0)
                            {
                                m3.date[nums].c=m1.date[i].c;
                                m3.date[nums].r=m1.date[i].r;
                                m3.date[nums].e=m1.date[i].e+m2.date[j].e;
                                nums++;
                                i++;
                                j++;
                            }
                        }
                    }


                    else if(m1.date[i].r<m2.date[j].r)
                    {
                        m3.date[nums].r=m1.date[i].r;
                        m3.date[nums].c=m1.date[i].c;
                        m3.date[nums].e=m1.date[i].e;
                        nums++;
                        i++;
                    }

                    else
                    {
                        m3.date[nums].r=m2.date[j].r;
                        m3.date[nums].c=m2.date[j].c;
                        m3.date[nums].e=m2.date[j].e;
                        j++;
                        nums++;
                    }

                    if(i==m1.nums)
                        {
                            if(j<m2.nums)
                            {
                                while(j<m2.nums)
                                {
                                    m3.date[nums].r=m2.date[j].r;
                                    m3.date[nums].c=m2.date[j].c;
                                    m3.date[nums].e=m2.date[j].e;
                                    nums++;
                                    j++;
                                }
                                break;
                            }
                        }

                else if(j==m2.nums)
                    {
                        if(i<m1.nums)
                        {
                            while(i<m1.nums)
                            {

                                m3.date[i].r=m1.date[i].r;
                                m3.date[i].c=m1.date[i].c;
                                m3.date[i].e=m1.date[i].e;
                                i++;
                                nums++;
                            }
                            break;
                        }
                    }

                 else if(i==m1.nums&&j==m2.nums)
                    {
                        break;
                    }


                }

                m3.rows=m1.rows;
                m3.cols=m1.cols;
                m3.nums=nums;

            }
————————————————
版权声明:本文为优快云博主「van之风」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.youkuaiyun.com/weixin_44077170/article/details/101480025

在C语言中,可以使用三元组 `(row, col, value)` 来表示稀疏矩阵,其中 `row` 和 `col` 分别代表元素所在的行和列索引,而 `value` 则是对应位置的值。这种数据结构通常称为“压缩存储”或“三元组列表”,因为它节省了空间,因为稀疏矩阵大部分位置都是零。 为了实现两个稀疏矩阵相加,我们可以创建两个这样的三元组数组,并维护它们各自的行和列索引范围。以下是基本步骤: ```c #include <stdio.h> #include <stdlib.h> typedef struct { int row; int col; double value; } SparseMatrixTriple; // 函数原型声明 SparseMatrixTriple* sparse_matrix_add(SparseMatrixTriple* a, SparseMatrixTriple* b, size_t* na, size_t* nb); // 实现稀疏矩阵相加 SparseMatrixTriple* sparse_matrix_add_helper(SparseMatrixTriple* a, SparseMatrixTriple* b, size_t a_len, size_t b_len) { SparseMatrixTriple* result = malloc(sizeof(SparseMatrixTriple) * (a_len + b_len)); size_t i = 0, j = 0, k = 0; while (i < a_len && j < b_len) { if (a[i].row == b[j].row && a[i].col == b[j].col) { result[k++] = (SparseMatrixTriple){ .row = a[i].row, .col = a[i].col, .value = a[i].value + b[j].value }; i++; j++; } else if (a[i].row < b[j].row) { result[k++] = a[i++]; } else { result[k++] = b[j++]; } } // 处理剩余的 a 或 b 中的非零元素 while (i < a_len) { result[k++] = a[i++]; } while (j < b_len) { result[k++] = b[j++]; } *na = a_len; *nb = b_len; return result; } int main() { size_t na, nb; SparseMatrixTriple* a = ...; // 初始化稀疏矩阵A的三元组列表 SparseMatrixTriple* b = ...; // 初始化稀疏矩阵B的三元组列表 SparseMatrixTriple* sum = sparse_matrix_add(a, b, &na, &nb); // 处理sum矩阵并打印结果 for (size_t i = 0; i < na + nb; i++) { printf("(%d,%d): %.2lf\n", sum[i].row, sum[i].col, sum[i].value); } free(sum); // 释放内存 return 0; } ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值