基于十字链表存储的稀疏矩阵C++源码

最新推荐文章于 2023-08-16 09:03:18 发布
最新推荐文章于 2023-08-16 09:03:18 发布
阅读量4.7k 收藏 6
点赞数 1
CC 4.0 BY-SA版权
分类专栏： V/C++ 文章标签： c++ 存储 delete matrix insert iostream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chuan014/article/details/1770837
介绍了一个名为KaKaMatrix的自定义稀疏矩阵类的设计与实现，该类支持基本矩阵运算如加法、乘法及转置，并提供了多种操作符重载以简化使用流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 这个不想说太多了，大家一看就明白，注意定义的几个操作符重载，用起来很方便。

KaKaMatrix km(10,10);

km.Insert(1,2,88);

KaKaMatrix km2(10,15);

KaKaMatrix km3=km2*km3;

cout<<km3;

大体是这样用吧， 代码是一上午写出来的，检查的时候，不是这里错，就是那里错，这里面非常可能还有错误，大家多指教。

KaKaMatrix.h

 

//KaKaMatrix.h文件

#pragma once
#include <iostream>
using namespace std;

typedef struct Matrix{
    int m;
    int n;
    int v;
    Matrix *Next;
    Matrix *Down;
    Matrix(int mm,int nn,int vv){
        m=mm;
        n=nn;
        v=vv;
        Next=Down=0;

    }
} *PMatrix;

class KaKaMatrix
{
public:
    KaKaMatrix(void);
    KaKaMatrix(int mm,int nn);
    KaKaMatrix(const KaKaMatrix& km);
    
public:
    void Init(int mm,int nn);
    void View(void);    
    int Insert(int mm, int nn, int vv);
    int Delete(int mm, int nn);    
    int Clear(void);
    int GetArray(int** PArr);
    int GetRow(void);
    int GetCol(void);
    KaKaMatrix Transpose(void);
    KaKaMatrix operator+(const KaKaMatrix& km);    
    KaKaMatrix operator*(const KaKaMatrix& km);
    KaKaMatrix& operator=(const KaKaMatrix& km);
public:
    ~KaKaMatrix(void);
    
private:
    int m,n,t;
    PMatrix *PMRow;
    PMatrix *PMCol;
    
};

ostream& operator<<(ostream& out,KaKaMatrix& km);//重载的输出操作符，可 cout<<KaKaMatrix 输

出。

 

KaKaMatrix.cpp

 

//KaKaMatrix.cpp文件

#include "KaKaMatrix.h"


KaKaMatrix::KaKaMatrix(void):m(0),n(0),t(0),PMRow(new PMatrix[m]),PMCol(new PMatrix[n])
{

}

KaKaMatrix::KaKaMatrix(int mm,int nn)
{
    this->m =mm;
    this->n =nn;
    this->PMRow=new PMatrix[m];
    this->PMCol=new PMatrix[n];

    for(int i=0;i!=m;++i){
        PMRow[i]=0;
    }
    for(int i=0;i!=n;++i){
        PMCol[i]=0;
    }
    t=0;

}

KaKaMatrix::KaKaMatrix(const KaKaMatrix& km)
{
    //重载的拷贝构造函数
    this->m =km.m ;
    this->n =km.n;
    this->PMRow=new PMatrix[m];
    this->PMCol=new PMatrix[n];
    this->t=0;


    for(int i=0;i!=m;++i){
        PMRow[i]=0;
    }
    for(int i=0;i!=n;++i){
        PMCol[i]=0;
    }

    for(int i=0;i!=km.m;++i){
        PMatrix t_p=km.PMRow[i] ;
        while(t_p){
            this->Insert(t_p->m+1,t_p->n+1,t_p->v);
            
            t_p=t_p->Next ;

        }
    }

    

}

KaKaMatrix::~KaKaMatrix(void)
{
    this->Clear();

}

void KaKaMatrix::Init(int mm,int nn)//可用于，先定义一个空矩阵，再初始化
{
    //删除所有结点
    this->Clear();

    this->m =mm;
    this->n =nn;
    this->PMRow=new PMatrix[m];
    this->PMCol=new PMatrix[n];

    for(int i=0;i!=m;++i){
        PMRow[i]=0;
    }
    for(int i=0;i!=n;++i){
        PMCol[i]=0;
    }

}



int KaKaMatrix::Insert(int mm, int nn, int vv)
{
    --mm;
    --nn;
    if(vv==0) return 0;
    
    if((mm>=m||nn>=n)||(mm<0||nn<0)) return 0;

    PMatrix t_pp=0;//保存行插入时新结点指针，用于列插入
    //行插入
    if(!this->PMRow[mm]){
        this->PMRow[mm]=new Matrix(mm,nn,vv);
        t_pp=this->PMRow[mm]->Next;//暂存

    }else{
        PMatrix t_p=this->PMRow[mm];

        while(t_p){
            if(t_p->n==nn){
                 t_p->v +=vv;
                 if(t_p->v==0){
                     //相加为零，删除结点
                     this->Delete(mm+1,nn+1);
                     return --t;

                 }
                
                 return t;
            }
            if((t_p->n<nn&&!t_p->Next)||(t_p->n<nn&&t_p->Next->n>nn)){
                t_p->Next=new Matrix(mm,nn,vv);
                t_pp=t_p->Next;
                return ++t;
            }
            t_p=t_p->Next ;
        }

    }
    //行插入结束，列插入开始

    if(!this->PMCol[nn]){
        this->PMCol[nn]=t_pp;

    }else{
        PMatrix t_p=this->PMCol[nn];

        while(t_p){
            if((t_p->m<mm&&!t_p->Down)||(t_p->m<mm&&t_p->Down->m>mm)){
                t_p->Down=t_pp;

            }
            t_p=t_p->Down ;

        }
    };
    return ++t;

    

}

int KaKaMatrix::Delete(int mm, int nn)
{
    //不带头结点，真是麻烦
    --mm;
    --nn;
    if((mm>=m||nn>=n)||(mm<0||nn<0)) return 0;

    PMatrix t_a = this->PMRow[mm] ;
    if(t_a&&(t_a->n==nn)){
        //删除第一行，第一列时出现的情况，不带头结点的缺点
        this->PMRow[mm]=this->PMRow[mm]->Next ;

    }else{
    
        while(t_a){
        
            if(t_a->n<nn&&t_a->Next->n==nn){            
            
                t_a->Next =t_a->Next->Next ;            
                break;
            }
         
            t_a=t_a->Next ;
        };
    }
    //列

    PMatrix t_b=this->PMCol[nn];
    if(t_b&&(t_b->m ==mm)){

        PMatrix t_delete=t_b;
        t_b =t_b->Down;
        delete t_delete;
        return 1;


    }else{
        while(t_b){    
            if(t_b->m<mm&&t_b->Down->m==mm){            
                PMatrix t_delete=t_b->Down;
                t_b->Down =t_b->Down->Down ;
                delete t_delete;
                return 1;
            }         
            t_b=t_b->Next ;
       };

    }

    
    

    return 0;
}

int KaKaMatrix::Clear(void)
{
    //清空矩阵，全为0
    for(int i=0;i!=m;++i){
        PMatrix t_p=this->PMRow[i] ;
        while(t_p){

            PMatrix t_delete=t_p;
            t_p=t_p->Next ;
            delete t_delete;

        }
    }
    delete [] PMRow;
    delete [] PMCol;
    PMRow=PMCol=0;
    
    t=0;

    return 1;
}


KaKaMatrix KaKaMatrix::Transpose(void)
{
    //返回一个转置矩阵
    KaKaMatrix out_km(this->n,this->m);

    for(int i=0;i!=m;++i){
        PMatrix t_p=this->PMRow[i] ;
        while(t_p){
            out_km.Insert(t_p->n+1,t_p->m+1,t_p->v);
            t_p=t_p->Next ;

        }
    }

    return out_km;
}



void KaKaMatrix::View(void)
{
    //打印输出矩阵
    //输出函数，空间复杂度　n*m ,时间复杂度不知道怎么算，执行循环总次数是 2*n*m+t+n。
    //有没有更好的办法
    //申请内存，全为０
    int **t_a=new int* [m];
    for(int i=0;i!=m;++i){
        t_a[i]=new int [n];
    }
    for(int i=0;i!=m;++i){
        for(int j=0;j!=n;++j){
            t_a[i][j]=0;
        }

    }
    //装填动态数组
    this->GetArray(t_a);

    cout<<endl<<"==========================================="<<endl;

    for(int i=0;i!=m;++i){
        
        for(int j=0;j!=n;++j){
            cout<<t_a[i][j]<<"  ";
        }
        cout<<endl;

    }
    cout<<"==========================================="<<endl;

    for(int i=0;i!=m;++i){
        delete [] t_a[i];
    }
    delete [] t_a;




        
}


int KaKaMatrix::GetRow(void)
{
    return m;
}

int KaKaMatrix::GetCol(void)
{
    return n;
}



KaKaMatrix KaKaMatrix::operator+(const KaKaMatrix& km)
{
    //重载矩阵加法
    if(km.m!=m||km.n!=n) 
       return KaKaMatrix(0,0);
    KaKaMatrix out_km(m,n);

    for(int i=0;i!=km.m;++i){
        PMatrix t_p=km.PMRow[i] ;
        while(t_p){
            out_km.Insert(t_p->m+1,t_p->n+1,t_p->v);
            
            t_p=t_p->Next ;

        }
    }

    for(int i=0;i!=m;++i){
        PMatrix t_p=this->PMRow[i] ;
        while(t_p){
            out_km.Insert(t_p->m+1,t_p->n+1,t_p->v);
            t_p=t_p->Next ;

        }
    }

    return out_km;


}



KaKaMatrix& KaKaMatrix::operator=(const KaKaMatrix& km)
{
    //重载赋值操作
    
    this->Init(km.m,km.n);

    for(int i=0;i!=km.m;++i){
        PMatrix t_p=km.PMRow[i] ;
        while(t_p){
            this->Insert(t_p->m+1,t_p->n+1,t_p->v);
            
            t_p=t_p->Next ;

        }
    }



    return *this;
}



KaKaMatrix KaKaMatrix::operator*(const KaKaMatrix& km)
{
    if(n!=km.m)
      return KaKaMatrix(0,0);
    KaKaMatrix out_km(m,km.n);
    //把矩阵1装入数组
    int **t_a=new int* [m];
    for(int i=0;i!=m;++i){
        t_a[i]=new int [n];
    }
    for(int i=0;i!=m;++i){
        for(int j=0;j!=n;++j){
            t_a[i][j]=0;
        }

    }
    this->GetArray(t_a);

    //把矩阵2装入数组
    int **t_b=new int* [km.m];
    for(int i=0;i!=km.m;++i){
        t_b[i]=new int [km.n];
    }
    for(int i=0;i!=km.m;++i){
        for(int j=0;j!=km.n;++j){
            t_b[i][j]=0;
        }

    }
    this->GetArray(t_b);

    //开始乘法
    //结果矩阵两层循环
    for(int i=0;i!=m;++i){
        for(int j=0;j!=km.n;++j){
            int t_item=0;
            //核心循环
            for(int g=0;g!=n;++g){
                t_item+=t_a[i][g]*t_b[g][j];

            }

            out_km.Insert(i+1,j+1,t_item);
            
        }
    }

    return out_km;



}

int KaKaMatrix::GetArray(int** PArr)
{
    
    //装填动态数组
    for(int i=0;i!=m;++i){
        PMatrix t_p=this->PMRow[i] ;
        while(t_p){
            PArr[t_p->m][t_p->n]=t_p->v;
            t_p=t_p->Next ;

        }
    }
    return 1;
}


ostream& operator<<(ostream& out,KaKaMatrix& km){


    //重载的输出操作符，可 cout<<KaKaMatrix 输出。
    int m=km.GetRow();
    int n=km.GetCol();
    int **t_a=new int* [m];
    for(int i=0;i!=m;++i){
        t_a[i]=new int [n];
    }
    for(int i=0;i!=m;++i){
        for(int j=0;j!=n;++j){
            t_a[i][j]=0;
        }

    }
    //装填动态数组
    km.GetArray(t_a);

    out<<endl<<"==========================================="<<endl;

    for(int i=0;i!=m;++i){
        
        for(int j=0;j!=n;++j){
            out<<t_a[i][j]<<"  ";
        }
        out<<endl;

    }
    out<<"==========================================="<<endl;

    for(int i=0;i!=m;++i){
        delete [] t_a[i];
    }
    delete [] t_a;


    return  out;
}









 

 

数据结构（廿三） -- C语言版 -- 图 - 图的存储结构 -- 邻接表、逆邻接表
青椒*^_^*凤爪爪的博客
08-15 1万+
在图中任何两个顶点之间都可能存在联系，所以图的存储结构应该需要根据具体问题的要求来进行设计。从图的逻辑结构定义来看，图中任何一个顶点都可以看成是第一个顶点。常用的存储结构有邻接矩阵、邻接表（逆邻接表）、十字链表、邻接多重表、 边集数组。那么本博文将带你就 “邻接表（逆邻接表）” 来窥探一二。。。
十字链表存储稀疏矩阵
老痒的农舍
07-24 539
原理借鉴率辉老师的2020天勤数据结构高分笔记P119-P121部分，代码部分未经大量数据验证可能存在bug，欢迎大家指正。 #include <bits/stdc++.h> using namespace std; /* * 普通节点 */ typedef struct Node { int r, c, v; Node *right, *down; } Node; /* ...
C/C++利用十字链表压缩存储存储稀疏矩阵
weixin_44915226的博客
06-24 883
利用三元组实现稀疏矩阵的压缩存储 代码 #include <iostream> #include <stdlib.h> using namespace std; //定义链表中的结点 typedef struct OLNode{ int i,j,e; struct OLNode *right,*down; }OLNode,*OLink; typedef struct{ OLink *rhead,*chead;//行和列链表头指针 int mu,nu,tu; //矩阵
稀疏矩阵的十字链表存储
weixin_34077371的博客
10-22 253
稀疏矩阵的压缩存储有几种方式，如：三元组顺序表、行逻辑链接的顺序表和十字链表。 使用链表存储的好处是：便于矩阵中元素的插入和删除。 例如：“将矩阵B加到矩阵A上”，那么矩阵A存储的元素就会有变动。比如会增加一些非零元，或者删除一些元素（因为bij+aij=0）。 下图是矩阵M和M的十字链表存储： 十字链表及其结点可用如下结构体表示： typedef struct OLNode{ ...
C++ 稀疏矩阵对应十字链表构建
HarvestWu的博客
06-01 1038
#include &lt;cstdio&gt; #include &lt;cstdlib&gt; #define maxSize 100 /* * Created by HarvestWu on 2018/6/1. */ typedef struct OLNode { int row,col; //行号和列号 struct OLNode *rig...
C语言实现稀疏矩阵的十字链表存储
dongchang0182的博客
03-15 1267
前两天在看课外的数据结构的书预习新知识的时候看到了一个特别有意思的稀疏矩阵问题，于是就按照书上的用C语言来实现之，刚学习数据结构的小白，请大佬们轻喷，下面上图： 下面是代码： #include<stdio.h>#include<stdlib.h> #define ElementType int typedef struct GNode *GList...
稀疏矩阵的十字链表存储的思路
热门推荐
菜鸟的逆袭
08-29 5万+
刚才终于完完全全、彻彻底底的搞明白了稀疏矩阵十字链表的存储方式的实现与该算法的思想。我觉得有必要把自己的思路记下来，一呢等自己将来忘记了可以回过头来看，二呢希望与我一样对该存储方式迷惑的朋友可以通过我的文章得到一点点的启示。现在进入正题。        我们知道稀疏矩阵的三元组
VC实现稀疏矩阵运算的数据结构实验详解
稀疏矩阵的存储方式有很多种，常见的有三元组表、十字链表、压缩行存储(CSR)、压缩列存储(CSC)等。在实际的编程实现中，需要选择一种合适的存储方法来优化存储空间和计算效率。例如，三元组表存储方式通过记录矩阵...
【稀疏矩阵操作手册】：掌握核心原理与高级技巧，提升数据处理效率
![【稀疏矩阵操作手册】：掌握核心原理与高级技巧...随后，深入探讨了稀疏矩阵的存储格式和基本操作，特别是在高级技巧中，压缩技术和高效算法的使用大幅提高了稀疏矩阵的处理效率。同时，文中还涉及了稀疏矩阵在科学计
C++经典源代码
03-22
十字链表是一种存储大整数的有效方式，每节点存储一个数字位，通过交叉指针链接相邻的数字。此程序可能涉及到链表的操作，如遍历、合并以及处理进位。 2. **表达式求值支持小数.cpp**： 这个程序可能实现了一个...
C语言实战项目：医院管理系统源码解析与WiFi连接功能
该项目实现中使用了十字链表法，这是数据结构中的一种方法，用于表示和操作双线性链表，常用于网络表示或稀疏矩阵的存储。 #### 十字链表法 十字链表法是一种图的存储方法，主要用于存储稀疏图（即边的数量相对于...
基于十字链表存储的稀疏矩阵的转置
04-28
实现了从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构（m、n分别表示矩阵行数和列数；i, j为非零元素行号和列号）和十字链表的转置并将转置后的三元组到另一字符文件中
十字链表稀疏矩阵相加
11-11
数据结构课程设计 十字链表稀疏矩阵相加 本课程设计主要实现在十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行相加，操作，最后输出运算后的结果。稀疏矩阵采用十字链表表示，并在不同的存储结构下，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C。
稀疏矩阵十字链表存储
12-26
资源有限，请谅解。原创作品，不喜勿喷。若有类似资源，请君主动共享。
DS_存储 稀疏矩阵 的十字链表(C++实现)
Acemanindisguise的博客
02-04 690
关于稀疏矩阵，就是值为0的元素数量很多的矩阵。如果把0元素位置看成空白，非零看成黑点，稀疏矩阵就像是一张照片，广阔的天空中只有远方的几只鸟。我也不知道这么理解对不对，瞎猜的。 至于矩阵的应用，书上说计算机图形学，工程技术中会用到，但现在我没整过具体的东西，所以就关于稀疏矩阵有啥用，以后碰到了再补上。 那么现在如何存储稀疏矩阵呢？怎样才能做到存的空间小，修改起来方便，使用的时候能快速呢。目前我只知道两种书上提到的方法： 1.三元组线性表 2.十字链表OrthogonalList 现在，就十字链表，使用C++实
十字链表法，十字链表压缩存储稀疏矩阵详解
最新发布
ZJQ的博客
08-16 4956
例如，A 和 B 分别为两个矩阵，在实现 "将矩阵 B 加到矩阵 A 上" 的操作时，矩阵 A 中的元素会发生很大的变化，之前的非 0 元素可能变为 0，而 0 元素也可能变为非 0 元素。对于此操作的实现，之前。可以看到，使用十字链表压缩存储稀疏矩阵时，矩阵中的各行各列都各用一各链表存储，与此同时，所有行链表的表头存储到一个数组（rhead），所有列链表的表头存储到另一个数组（chead）中。图 2a) 表示的是图 1 中转置之前矩阵的三元组表，2b) 表示的是图 1 中矩阵转置后对应的三元组表。
5.3稀疏矩阵的十字链表存储
IT1995的博客
02-11 8863
5.3稀疏矩阵的十字链表存储
（转载）十字链表法，十字链表压缩存储稀疏矩阵详解
无
02-25 1492
原文链接：http://data.biancheng.net/view/186.html 对于压缩存储稀疏矩阵，无论是使用三元组顺序表，还是使用行逻辑链接的顺序表，归根结底是使用数组存储稀疏矩阵。介于数组 “不利于插入和删除数据” 的特点，以上两种压缩存储方式都不适合解决类似 “向矩阵中添加或删除非 0 元素” 的问题。 例如，A 和 B 分别为两个矩阵，在实现 “将矩阵 B 加到矩阵 A 上” 的操作时，矩阵 A 中的元素会发生很大的变化，之前的非 0 元素可能变为 0，而 0 元素也可能变为非 0 元素
C++实现十字链表稀疏矩阵
这些代码展示了如何使用C++实现十字链表来存储和操作稀疏矩阵，对于理解和处理大规模稀疏数据具有实际意义。通过这种数据结构，可以高效地进行矩阵操作，如查找、插入和删除，同时减少对内存的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值