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

最新推荐文章于 2024-04-04 15:34:37 发布
最新推荐文章于 2024-04-04 15:34:37 发布
阅读量4.7k 收藏 6
点赞数 1
分类专栏： V/C++ 文章标签： c++ 存储 delete matrix insert iostream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuan014/article/details/1770837
版权

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

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 ;
}

 

 

chuan014
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于十字链表存储的稀疏矩阵的转置
04-28
在本文中，我们将深入探讨如何使用C++实现基于十字链表的稀疏矩阵转置。首先，我们需要了解稀疏矩阵的概念。在计算机科学中，稀疏矩阵是指大部分元素为零的矩阵，通常用以节省存储空间。对于这类矩阵，我们通常采用...
C/C++利用十字链表压缩存储存储稀疏矩阵
weixin_44915226的博客
06-24 812
利用三元组实现稀疏矩阵的压缩存储 代码 #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; //矩阵
稀疏矩阵的存储与获取（十字链表法 C++版）
weixin_42295110的博客
07-13 1322
此稀疏矩阵我们打算采用十字链表法进行存储。 代码实现及结果测试: #include<stdio.h> #include<stdlib.h> #define null NULL #define N 4 //矩阵的行数 #define M 7 //矩阵的列数 /* 稀疏矩阵的十字链表法实现方式 */ //十字链表的元素结点 typedef struct OLNode{ int i,j,value; //i行标 j列标 value元素值 struc...
数据结构 - 十字链表之稀疏矩阵的存储
爱吃柚子的好奶罐
02-19 9738
当数组中非零元素非常少时，我们可以称之为稀疏矩阵。为了减少空间的浪费，在存储稀疏矩阵的时候，我们对它进行压缩存储，即指存储非零信息。 一、数组的顺序存储 在存储稀疏矩阵的时候，除了存储非零元素的值，还需要存储其行列号i和j，故每个非零元素要用一个三元组（i, j, v）来描述。因为要与矩阵的对应关系，我们还需要在三元组表中增设非零元素的个数和矩阵行列大小。 那么，稀疏矩阵的数组表达如下所示。 st...
KMCT分页控件与存储过程分页完美结合---存储过程分页篇(原创)
diaohuangqiu0536的博客
02-28 145
上一篇分页控件(KCMT开源控件之--方便简洁的分页控件 )出来以后，好几位网友期待我的存储过程分页与该控件结合使用的例程，这个星期工作很忙，一直没有时间完成。今天终于抽出时间来完成这篇文章。 首先从存储过程分页谈起 为什么要选择用存储过程分页呢？其实原因很简单，数据库查询功能的性能终究是有限的。即使我们对数据库进行了最优配置，对数据表设计再三斟酌，然而一旦面临海量数据，且返...
ODI之知识模块(KM)学习笔记二（API 对象） .
hfxl1108的专栏
10-26 1166
主要对几个常见的ODI 对象进行学习，学习过程中也发现了一个详细的API Methods 链接： http://gerardnico.com/doc/odi/webhelp/en/ref_api/  1. getTable() 2.getColList() All of them return a string and accept at least these 4 parameter
十字链表实现稀疏矩阵的各种功能
11-19
十字链表实现稀疏矩阵的加法、减法、乘法、转置、求最值、插入、查看、删除等基本功能，菜单栏采用hash表存储稀疏矩阵，给每个矩阵存储一个名字，hash函数进行寻找。
稀疏矩阵十字链表存储
12-26
源程序中，我们使用C++语言实现了稀疏矩阵十字链表存储的方法。我们定义了一个链表节点结构体，包含行号、列号和元素值信息。然后，我们实现了创建空十字链表、输入非零元素、显示十字链表等函数。 稀疏矩阵十字链...
十字链表实现稀疏矩阵的乘法
09-03
用C++编写的稀疏矩阵乘法运算，稀疏矩阵采用十字链表存储及计算
十字链表实现稀疏矩阵的加法
12-10
在实现稀疏矩阵的加法运算时，我们可以使用十字链表来存储稀疏矩阵，并定义两个类：结点类MatrixNode和链表类LinkMatrix。MatrixNode类用于存储非零元素的三元组，并设置right和down两个指针。LinkMatrix类用于管理...
【数据结构】稀疏矩阵的链式存储（十字链表）
Ctrl AC的博客
03-13 1万+
“ Ctrl AC！一起 AC！” 目录 稀疏矩阵的十字链表表示： 十字链表中结点的结构： 创建稀疏矩阵的十字链表表示： 稀疏矩阵十字链表的查找： 稀疏矩阵的十字链表表示： 每一行的非零元素构成一个带表头的环形链表 每一列的非零元素构成一个带表头的环形链表 第i行和第i列的表头是同一个 所有表头结点构成一个新的带表头的环形链表 因此： 十字链表的表示中有非零元素结点和表头结点两类结点 其中表头结点的row,col均为零，表头结点构成的环形链表的表头的row和col分.
十字链表法，十字链表压缩存储稀疏矩阵详解
ZJQ的博客
08-16 3997
例如，A 和 B 分别为两个矩阵，在实现 "将矩阵 B 加到矩阵 A 上" 的操作时，矩阵 A 中的元素会发生很大的变化，之前的非 0 元素可能变为 0，而 0 元素也可能变为非 0 元素。对于此操作的实现，之前。可以看到，使用十字链表压缩存储稀疏矩阵时，矩阵中的各行各列都各用一各链表存储，与此同时，所有行链表的表头存储到一个数组（rhead），所有列链表的表头存储到另一个数组（chead）中。图 2a) 表示的是图 1 中转置之前矩阵的三元组表，2b) 表示的是图 1 中矩阵转置后对应的三元组表。
十字链表实现矩阵存储
qq_53363981的博客
07-04 2747
一、介绍 用十字链表存储稀疏矩阵，可以起到节省空间的作用。 十字链表作为多重链表的一种，其结点分为两种： 类型1：数据域为另一个单链表的头指针。 类型2：数据域为待存储的数据。 其中，“十字”体现在：每一个存储数据的节点都属于两个单链表，从而构成十字形。 用十字链表表示的矩阵，有着以下特征： 1、整体的头指针指向最初的头结点，该头结点一般用于存储矩阵的行数、列数以及其中包含非0元素的数量。 2、由最初的头结点分别横向、纵向展开两个单链表，这两个链表中的每个结点都为类型1。 3、这两个.
稀疏矩阵的链式存储结构：十字链表
最新发布
2302_80372340的博客
04-04 1094
int row;//1~n//非零元素所在行，列后继链域//行，列链表的头指针向量int m;//行数int n;//列数int len;//非零元素个数}CrossList;
【数据结构】数组和字符串（八）：稀疏矩阵的链接存储：十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-28 1068
本文介绍了稀疏矩阵的链接存储：包括十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁等基本操作
【数据结构】稀疏矩阵的压缩存储（三元组表、十字链表）（C语言）
热门推荐
weixin_51450101的博客
01-27 1万+
目录1. 三元组表1.1 三元组表的存储结构1.2 基于三元组表的矩阵转置1.3 完整实现代码1.4 运行结果2. 十字链表2.1 十字链表的存储结构 稀疏矩阵是指矩阵中大多数元素为零的矩阵。从直观上讲，当非零元素个数低于总元素的30%时，这样的矩阵为稀疏矩阵。 1. 三元组表 1.1 三元组表的存储结构 稀疏矩阵的三元组表表示法是指只存储非零元素，同时存储该非零元素在矩阵中所处的行号和列号的位置信息。 为方便处理，将稀疏矩阵中非零元素对应的三元组按“行序为主序”的一维结构体数组进行存放，将矩阵的每一行（行
十字链表 c++实现
新人
12-17 533
十字链表 c++实现 十字链表面向有向图的另一种链表存储结构，包含了领接表和逆领接表的特性，可以快速的访问出弧和入弧，得到出度和入度。 #include<iostream> using namespace std; const int maxNum = 100; typedef struct arcNode { //弧结点类型 int tail; //弧尾下标 in...
c++数据结构：图（十字链表和邻接多重表）
qq_45303986的博客
10-20 563
十字链表：是有向图的一种链式存储结构，可以看作是有向图的邻接表和逆邻接表的一种结合体。由于有向的图，不易查找该节点的度，十字链表可以解决这个问题。
十字链表存储稀疏矩阵
慎铭的博客
11-23 3290
  对于矩阵的存储，如果矩阵的元素呈有明显规律的排列的话，我们一般用一个一维数组对矩阵进行压缩存储；若矩阵中的元素多数为0，只有少数的元素为非0元素时，我们成该矩阵为稀疏矩阵。 我们有矩阵Aij，其中有非0元素m个，若mij≤0.05，则我们称矩阵Aij为稀疏矩阵 我们有矩阵A_{ij}，其中有非0元素m个，若\frac{m}{ij} \le 0.05，则我们称矩阵A_{ij}为稀疏矩阵 我们有矩阵Aij​，其中有非0元素m个，若ijm​≤0.05，则我们称矩阵Aij​为稀疏矩阵   对于稀疏矩阵，因为非零
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值