第9周项目3-稀疏矩阵的三元组表示的实现及应用(2)

稀疏矩阵加法算法
本文介绍了两种实现稀疏矩阵加法的算法。第一种通过遍历矩阵元素并直接计算和来实现,第二种则利用三元组存储结构,比较并合并两个稀疏矩阵的非零元素,最终形成新的稀疏矩阵。

问题及代码:

/*
Copyright (c)2016,烟台大学计算机与控制工程学院
All rights reserved.
文件名称:ice.cbp
作    者:何大冰
完成日期:2016年11月3日
版 本 号:v1.0


问题描述:(2)采用三元组存储稀疏矩阵,设计两个稀疏矩阵相加的运算算法  
 
 
输入描述:无 
程序输出:测试数据 
*/  

方法一:

#include <stdio.h>
#include "tup.h"
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)
{
    int i,j;
    ElemType va,vb,vc;
    if (a.rows!=b.rows || a.cols!=b.cols)
        return false;                        //行数或列数不等时不能进行相加运算
    c.rows=a.rows;
    c.cols=a.cols;       //c的行列数与a的相同
    c.nums=0;
    for(i=0; i<M; i++)
        for(j=0; j<N; j++)
        {
            Assign(a,va,i,j);
            Assign(b,vb,i,j);
            vc=va+vb;
            if(vc)
                Value(c,vc,i,j);
        }
    return true;
}

int main()
{
    TSMatrix ta,tb,tc;
    int A[M][N]=
    {
        {0,0,1,0,0,0,0},
        {0,2,0,0,0,0,0},
        {3,0,0,0,0,0,0},
        {0,0,0,5,0,0,0},
        {0,0,0,0,6,0,0},
        {0,0,0,0,0,7,4}
    };
    int B[M][N]=
    {
        {0,0,10,0,0,0,0},
        {0,0,0,20,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,50,0,0,0},
        {0,0,20,0,0,0,0},
        {0,0,0,10,0,0,4}
    };
    CreatMat(ta,A);
    CreatMat(tb,B);
    printf("A:\n");
    DispMat(ta);
    printf("B:\n");
    DispMat(tb);
    if(MatAdd(ta, tb, tc))
    {
        printf("A+B:\n");
        DispMat(tc);
    }
    else
    {
        printf("相加失败\n");
    }
    return 0;
}

方法二:

#include <stdio.h>
#include "tup.h"
bool MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)
{
    int i=0,j=0,k=0;
    ElemType v;
    if (a.rows!=b.rows || a.cols!=b.cols)
        return 0;        //行数或列数不等时不能进行相加运算
    c.rows=a.rows;
    c.cols=a.cols;       //c的行列数与a的相同
    while (i<a.nums && j<b.nums)         //处理a和b中的每个元素
    {
        if (a.data[i].r==b.data[j].r)    //行号相等时
        {
            if(a.data[i].c<b.data[j].c)  //a元素的列号小于b元素的列号
            {
                c.data[k].r=a.data[i].r;//将a元素添加到c中
                c.data[k].c=a.data[i].c;
                c.data[k].d=a.data[i].d;
                k++;
                i++;
            }
            else if (a.data[i].c>b.data[j].c)//a元素的列号大于b元素的列号
            {
                c.data[k].r=b.data[j].r;      //将b元素添加到c中
                c.data[k].c=b.data[j].c;
                c.data[k].d=b.data[j].d;
                k++;
                j++;
            }
            else                    //a元素的列号等于b元素的列号
            {
                v=a.data[i].d+b.data[j].d;
                if (v!=0)           //只将不为0的结果添加到c中
                {
                    c.data[k].r=a.data[i].r;
                    c.data[k].c=a.data[i].c;
                    c.data[k].d=v;
                    k++;
                }
                i++;
                j++;
            }
        }
        else if (a.data[i].r<b.data[j].r) //a元素的行号小于b元素的行号
        {
            c.data[k].r=a.data[i].r;      //将a元素添加到c中
            c.data[k].c=a.data[i].c;
            c.data[k].d=a.data[i].d;
            k++;
            i++;
        }
        else                              //a元素的行号大于b元素的行号
        {
            c.data[k].r=b.data[j].r;      //将b元素添加到c中
            c.data[k].c=b.data[j].c;
            c.data[k].d=b.data[j].d;
            k++;
            j++;
        }
    }
    while (i<a.nums)         //a中尚有元素时
    {
        c.data[k].r=a.data[i].r;//将a元素添加到c中
        c.data[k].c=a.data[i].c;
        c.data[k].d=a.data[i].d;
        k++;
        i++;
    }
    while (j<b.nums)         //b中尚有元素时
    {
        c.data[k].r=b.data[j].r;      //将b元素添加到c中
        c.data[k].c=b.data[j].c;
        c.data[k].d=b.data[j].d;
        k++;
        j++;
    }
    c.nums=k;
    return true;
}

int main()
{
    TSMatrix ta,tb,tc;
    int A[M][N]=
    {
        {0,1,0,0,0,0,0},
        {0,2,0,0,0,0,0},
        {3,0,0,0,0,0,0},
        {0,0,0,5,0,0,0},
        {0,0,0,0,6,0,0},
        {0,0,0,0,0,7,4}
    };
    int B[M][N]=
    {
        {0,0,10,0,0,0,0},
        {0,0,0,20,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,50,0,0,0},
        {0,0,20,0,0,0,0},
        {0,0,0,10,0,0,4}
    };
    CreatMat(ta,A);
    CreatMat(tb,B);
    printf("A:\n");
    DispMat(ta);
    printf("B:\n");
    DispMat(tb);
    if(MatAdd(ta, tb, tc))
    {
        printf("A+B:\n");
        DispMat(tc);
    }
    else
    {
        printf("相加失败\n");
    }
    return 0;
}




运行结果:




知识点总结:

稀疏矩阵的三元组的实现及其进一步的应用。。



心得体会:

对稀疏矩阵的三元组的应用更加熟悉了




<think>好的,用户让我介绍一下稀疏矩阵三元组转置。我需要先回忆一下相关的知识,确保自己理解正确。首先,稀疏矩阵是指大部分元素为零的矩阵,为了节省存储空间,通常会用三元组的形式来表示,也就是记录每个非零元素的行号、列号和值。转置操作就是把矩阵的行和列交换,所以对于三元组来说,原本的行号变成列号,列号变成行号,但值不变。不过,直接交换行和列可能不会保持原来的行优先顺序,所以需要考虑如何高效地进行转置。 接下来,我应该分步骤解释转置的过程。首先,可能需要解释三元组存储的结构,比如每个元素包括row、col、value。然后,转置后的矩阵需要每个元素的row和col交换,但如何保持新的行顺序呢?因为原矩阵是按行优先存储的,转置后的矩阵应该按列优先,也就是行号从小到大排列。这时候,可能需要用到某种排序方法,比如先按列号排序原三元组,然后交换行列,或者使用快速转置算法,避免显式排序。 然后,我需要考虑两种方法:普通转置和快速转置。普通转置可能涉及遍历原矩阵的每一列,将对应列的元素放到转置后的行中,但这样时间复杂度可能较高,尤其是当列数很多的时候。而快速转置算法则通过预先统计每列的非零元素数量,确定转置后每行的起始位置,从而一次性放置元素,提高效率。 在解释过程中,要注意使用例子来说明。例如,给出一个原始的三元组,展示转置后的结果,并说明步骤。同时,比较不同方法的时间复杂度,普通转置是O(cols*elements),而快速转置是O(cols + elements),更适合大规模数据。 另外,需要提醒用户注意实现时的细节,比如索引是从0还是1开始,以及如何处理相同行列的情况,确保转置后的矩阵正确无误。可能还需要提到稀疏矩阵转置的应用场景,比如在数值计算、图像处理等领域,节省存储和计算资源。 最后,要确保回答结构清晰,按照用户的要求分步骤说明,使用中文,数学公式用正确的LaTeX格式,行内公式用$...$,独立公式用$$...$$。检查是否有遗漏的步骤或可能的误解,确保信息准确可靠。</think>稀疏矩阵三元组转置是一种优化存储和计算效率的算法。以下分步骤详细介绍: --- ### **1. 三元组表示** 稀疏矩阵的非零元素用三元组$(row, col, value)$存储,例如: $$ \begin{bmatrix} 0 & 5 & 0 \\ 3 & 0 & 0 \\ 0 & 0 & 9 \\ \end{bmatrix} $$ 对应的三元组为: $$(0,1,5),\ (1,0,3),\ (2,2,9)$$ --- ### **2. 转置定义** 矩阵转置是将原矩阵的行列互换。例如,上述矩阵转置后为: $$ \begin{bmatrix} 0 & 3 & 0 \\ 5 & 0 & 0 \\ 0 & 0 & 9 \\ \end{bmatrix} $$ 对应新三元组:$$(0,1,3),\ (1,0,5),\ (2,2,9)$$ --- ### **3. 转置算法步骤** #### **(1) 普通转置法** - **时间复杂度**:$O(\text{cols} \times \text{num\_elements})$ - **步骤**: 1. 遍历原三元组,对所有元素交换其$row$和$col$。 2. 按照新的$row$(原$col$)进行排序。 **示例**: 原三元组$(0,1,5),\ (1,0,3),\ (2,2,9)$ 交换行列后:$(1,0,5),\ (0,1,3),\ (2,2,9)$ 按新$row$排序后:$(0,1,3),\ (1,0,5),\ (2,2,9)$ --- #### **(2) 快速转置法** - **时间复杂度**:$O(\text{cols} + \text{num\_elements})$ - **步骤**: 1. 统计原矩阵每列的非零元素数(即转置后每行的非零数)。 2. 计算转置后每行的起始位置。 3. 遍历原三元组,按新起始位置填入转置结果。 **公式定义**: - 设原矩阵有$cols$列,$num\_elements$个非零元素。 - 转置后第$i$行的起始位置为: $$ \text{start\_pos}[i] = \sum_{k=0}^{i-1} \text{count}[k] $$ 其中$\text{count}[k]$是原矩阵第$k$列的非零元素数。 --- ### **4. 算法对比** | 方法 | 时间复杂度 | 适用场景 | |------------|--------------------------|-----------------------| | 普通转置 | $O(\text{cols} \times \text{num\_elements})$ | 小规模矩阵 | | 快速转置 | $O(\text{cols} + \text{num\_elements})$ | 大规模稀疏矩阵 | --- ### **5. 实现注意事项** - 索引通常从0开始(需与编程语言一致)。 - 若存在多个相同行列元素,需合并或按规则处理。 - 适用于科学计算(如有限元分析)、图像压缩等领域。 通过合理选择算法,可高效实现稀疏矩阵的转置操作。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值