稀疏矩阵三元存储下的计算器

最新推荐文章于 2018-11-10 00:59:59 发布
最新推荐文章于 2018-11-10 00:59:59 发布
阅读量162 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/dilidingzhi/p/4028665.html

又是一个实验题：三元数组存储稀疏矩阵，同时实现基本的加法，减法，乘法，求逆

             思路：

                         首先规范好输入情况

                         明确三元数组的数据结构和输入特征(   行优先输入 

                                                                                   )

                         

                          将稀疏矩阵建立成三元数组和三元数组转化输出

                          数组的加法，减法（

                                                         根据输入的行与列来判断是否可以进行 

                                                         最后的运算结果仍是稀疏矩阵 

                                                          输出结果为矩阵

                                                         ）

   思路实现

       

                         明确三元数组的数据结构和输入特征(   行优先输入 

                                                                                   )

             

typedef struct 
{
    int row;
    int col;
    ElementType value;
}Triple;

typedef struct 
{
    Triple data[MAXSIZE];
    int rows,cols,nums;//非零起
}TSMatrix;

　　

                          将稀疏矩阵建立成三元数组和三元数组转化输出

PtrTSMatrix CreatMatrix( void )
{

    int count = 0;
     PtrTSMatrix Matrix;
    Matrix  = ( PtrTSMatrix )malloc( sizeof( TSMatrix ) );
     if( Matrix == NULL )
     {
         printf("Not Space\n ");
         exit( 0 );
     }

     printf("输入行与列\n");
     scanf("%d%d",&Matrix->rows,&Matrix->cols);

     printf("输入矩阵的元素的行，列，值( -1 结束 ，行优先)\n");
     scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
     while( Matrix->data[count].row != -1 )
     {
         count++;
         scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
         if( Matrix->data[count].row < Matrix->data[count-1].row && Matrix->data[count].row!=-1 )
        {
            printf("未按行输出:\n");
            getchar();
            exit(0);
        }//if
     }//while
    Matrix->nums = count;

     return Matrix;

}/* CreatMatrix */

/* print the matrix Matrix by using matrix */
void PrintMatrix( PtrTSMatrix Matrix )
{
      int i,j;
      int count = 0;
      
      for( i=0; i<Matrix->rows; i++ )
      {
          for( j=0; j<Matrix->cols; j++ )
          {
              if( count<Matrix->nums && i==Matrix->data[count].row-1 && j==Matrix->data[count].col-1 )
              {
                  printf("%2d",Matrix->data[count].value);
                  count++;
              }
              else
              {
                  printf("%2d",0);
              }//if-else
          }//for
          printf("\n");
      }//for
}/* PrintMatrix */

PtrTSMatrix CreatMatrix( void )
{

    int count = 0;
     PtrTSMatrix Matrix;
    Matrix  = ( PtrTSMatrix )malloc( sizeof( TSMatrix ) );
     if( Matrix == NULL )
     {
         printf("Not Space\n ");
         exit( 0 );
     }

     printf("输入行与列\n");
     scanf("%d%d",&Matrix->rows,&Matrix->cols);

     printf("输入矩阵的元素的行，列，值( -1 结束 ，行优先)\n");
     scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
     while( Matrix->data[count].row != -1 )
     {
         count++;
         scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
         if( Matrix->data[count].row < Matrix->data[count-1].row && Matrix->data[count].row!=-1 )
        {
            printf("未按行输出:\n");
            getchar();
            exit(0);
        }//if
     }//while
    Matrix->nums = count;

     return Matrix;

}/* CreatMatrix */

 

                          数组的加法，减法（

                                                         根据输入的行与列来判断是否可以进行 

                                                         最后的运算结果仍是稀疏矩阵 

                                                        ）

     一般人最先想到的是两个for循环吧，那么算法的效率为 O( M *N ),我将算法稍稍改进了一下，优化到了 O（M+N ），具体思路如下

11 1
222
333

 x

y 

 vaule
   

 类似上面那个三元组，在一个矩阵中想要确认位置需要x，y两个数据，实际上我可以把它回归到它在内存中存储得形式，即是线性存储，每一元素有唯一得一个对应值（假设矩阵为3×3），这样在就可以在一次循环中比较了

11
52
93
flag vaule 
  

                       

              while( 没有一个三元组被遍历完 )

               {

                          if（俩个三元组位置相同）

                          {

                                 将两个三元组得位置信息和和传递给新的三元组

                                 两个三元组都向后移一位

                         }

                        elseif(  其中一个三元组的元素在另一个之前 )

                        {

                               将位于前面得元素的位置信息和值传给新得三元组

                               向后移一位

                          }

              } 

 

/* Plus A and B ,return C */
PtrTSMatrix AddMatrix( PtrTSMatrix A, PtrTSMatrix B )
{
    int i=0,j=0;//标记追逐 A  B 
    PtrTSMatrix C;//存放和

   if( A->rows!=B->rows || A->cols!=B->cols )
   {
       return NULL;
   }
   
   C = ( PtrTSMatrix )malloc(sizeof( TSMatrix ));
   C->rows = A->rows;
   C->cols = A->cols;
   C->nums = -1; //初始化
   
   while( i<A->nums && j<B->nums )
   {
       if( A->data[i].row*A->cols+A->data[i].col == B->data[j].row*B->cols+B->data[j].col )
       {
           if( A->data[i].value+B->data[j].value != 0 )
           {
             C->nums++;
             C->data[C->nums].col = A->data[i].col;
             C->data[C->nums].row = A->data[i].row;
             C->data[C->nums].value = A->data[i].value+B->data[j].value;
           }
           i++;
           j++;//标记后移
       }
       else if( A->data[i].row*A->cols+A->data[i].col < B->data[j].row*B->cols+B->data[j].col )
       {
             C->nums++;
             C->data[C->nums].col = A->data[i].col;
             C->data[C->nums].row = A->data[i].row;
             C->data[C->nums].value = A->data[i].value;
             i++;
       }
       else
       {
             C->nums++;
             C->data[C->nums].col = B->data[j].col;
             C->data[C->nums].row = B->data[j].row;
             C->data[C->nums].value = B->data[j].value;
             j++;
       }//if-else

   }//while,

   if( i == A->nums )
   {
       while( j < B->nums )
       {
             C->nums++;
             C->data[C->nums].col = B->data[j].col;
             C->data[C->nums].row = B->data[j].row;
             C->data[C->nums].value = B->data[j].value;
             j++;
       }
   }
   else 
   {
       while( i < A->nums )
       {
             C->nums++;
             C->data[C->nums].col = A->data[i].col;
             C->data[C->nums].row = A->data[i].row;
             C->data[C->nums].value = A->data[i].value;
             i++;
       }
   }//if-else

   C->nums++;

   return C;
}//AddMatrix

　　  矩阵乘法的实现：

。

          原文链接  （详细的解释了原理和B矩阵的两个辅助矩阵构造，但对于算法的实现没有详讲）

         总得来说，在稀疏矩阵中，C=A乘B是对应行和对应列中非零值的事，例如在A 中  i  行中的第一个非零值 A[i][j]，可以和它相乘的只有B的 j 行的非零值B[j][k]，而且相乘结果还是放在C[i][k]中，这样把A中的非零值都与

       如果给你一张纸来计算A×B，你肯定会先是A的第一行和B的第一列相乘，放在C[0][0]的位置，之后是和B的第二列相乘，放在C[0][1]中，当B的列算到头后，再从A的第二行开始，是吧？但要让计算机对三元组这样操作显然不行，因为你很难确定B三元组的任意一列（当然你要转置，我自然不说什么）。

那么该怎么做呢？ 

     A 0 1 0 1   　　　B 1 0 ０   　　　Ｃ = ?            

        0 0 1 0    　　　  3 2 ０

                                 0 1 0

                                 0 0 2　                                       

 首先从A中取的第一个值，这个值是　[ 1 2 1 ]([]内的值分别表示其x,y,vaule)，那么在整个乘法过程中能和这个值相乘的也只有Ｂ中的第二行的[ 2  1 3 ] ,[ 2 2 2]

并且是放在C的第一行中的不同列的。那么能这么干嘛

(1).从Ａ三元组中按顺序取一值　[ x  y  z ],那么找到对应的B的ｙ　

  

 

 

 

PtrTSMatrix AddMatrix( PtrTSMatrix A, PtrTSMatrix B )
{
	int i=0,j=0;//标记追逐 A  B 
	PtrTSMatrix C;//存放和

   if( A->rows!=B->rows || A->cols!=B->cols )
   {
	   return NULL;
   }
   
   C = ( PtrTSMatrix )malloc(sizeof( TSMatrix ));
   C->rows = A->rows;
   C->cols = A->cols;
   C->nums = -1; //初始化
   
   while( i<A->nums && j<B->nums )
   {
	   if( A->data[i].row*A->cols+A->data[i].col == B->data[j].row*B->cols+B->data[j].col )
	   {
		   if( A->data[i].value+B->data[j].value != 0 )
		   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value+B->data[j].value;
		   }
		   i++;
		   j++;//标记后移
	   }
	   else if( A->data[i].row*A->cols+A->data[i].col < B->data[j].row*B->cols+B->data[j].col )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
	   else
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }//if-else

   }//while,

   if( i == A->nums )
   {
	   while( j < B->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }
   }
   else 
   {
	   while( i < A->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
   }//if-else

   C->nums++;

   return C;
}//AddMatrix

　　下面是可直接编译运行的代码:

/*************************************************************************
	> File Name: Matrix.c
	> Author: zh
	> Mail: 574932286@qq.com 
	> Created Time: 2014年10月16日 星期四 13时37分05秒
	
	一： 完成稀疏矩阵的建立i
    二： 15：33 稀疏矩阵的加法
         10,16 8:30 继续实现
		 10.19 15:07 继续
    三： 10.20 00：44 稀疏矩阵得乘法	
 ************************************************************************/
#include<stdlib.h>
#include<stdio.h>
#define MAXSIZE 100
typedef int ElementType; 
typedef struct 
{
	int row;
	int col;
	ElementType value;
}Triple;

typedef struct 
{
	Triple data[MAXSIZE];
	int rows,cols,nums;//非零起
}TSMatrix;

typedef TSMatrix * PtrTSMatrix;

PtrTSMatrix CreatMatrix( void );
void PrintMatrix( PtrTSMatrix Matrix );
PtrTSMatrix AddMatrix( PtrTSMatrix A, PtrTSMatrix B );
PtrTSMatrix MinusMatrix( PtrTSMatrix A, PtrTSMatrix B );
PtrTSMatrix MultiMatrix( PtrTSMatrix A, PtrTSMatrix B );
/* Make a Matrix,use the triple array */
PtrTSMatrix CreatMatrix( void )
{

    int count = 0;
     PtrTSMatrix Matrix;
    Matrix  = ( PtrTSMatrix )malloc( sizeof( TSMatrix ) );
	 if( Matrix == NULL )
     {
		 printf("Not Space\n ");
		 exit( 0 );
     }

     printf("输入行与列\n");
	 scanf("%d%d",&Matrix->rows,&Matrix->cols);

	 printf("输入矩阵的元素的行，列，值( -1 结束 ，行优先)\n");
     scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
	 while( Matrix->data[count].row != -1 )
	 {
         count++;
         scanf("%d%d%d",&Matrix->data[count].row,&Matrix->data[count].col,&Matrix->data[count].value);
		 if( Matrix->data[count].row < Matrix->data[count-1].row && Matrix->data[count].row!=-1 )
        {
			printf("未按行输出:\n");
			getchar();
			exit(0);
		}//if
	 }//while
    Matrix->nums = count;

	 return Matrix;

}/* CreatMatrix */

/* print the matrix Matrix by using matrix */
void PrintMatrix( PtrTSMatrix Matrix )
{
      int i,j;
	  int count = 0;
      
	  for( i=0; i<Matrix->rows; i++ )
	  {
		  for( j=0; j<Matrix->cols; j++ )
		  {
			  if( count<Matrix->nums && i==Matrix->data[count].row-1 && j==Matrix->data[count].col-1 )
			  {
  				  printf("%2d",Matrix->data[count].value);
				  count++;
			  }
			  else
			  {
				  printf("%2d",0);
			  }//if-else
		  }//for
		  printf("\n");
	  }//for
}/* PrintMatrix */


/* Plus A and B ,return C */
PtrTSMatrix AddMatrix( PtrTSMatrix A, PtrTSMatrix B )
{
	int i=0,j=0;//标记追逐 A  B 
	PtrTSMatrix C;//存放和

   if( A->rows!=B->rows || A->cols!=B->cols )
   {
	   return NULL;
   }
   
   C = ( PtrTSMatrix )malloc(sizeof( TSMatrix ));
   C->rows = A->rows;
   C->cols = A->cols;
   C->nums = -1; //初始化
   
   while( i<A->nums && j<B->nums )
   {
	   if( A->data[i].row*A->cols+A->data[i].col == B->data[j].row*B->cols+B->data[j].col )
	   {
		   if( A->data[i].value+B->data[j].value != 0 )
		   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value+B->data[j].value;
		   }
		   i++;
		   j++;//标记后移
	   }
	   else if( A->data[i].row*A->cols+A->data[i].col < B->data[j].row*B->cols+B->data[j].col )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
	   else
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }//if-else

   }//while,

   if( i == A->nums )
   {
	   while( j < B->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }
   }
   else 
   {
	   while( i < A->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
   }//if-else

   C->nums++;

   return C;
}//AddMatrix
/* A mius B get C */
PtrTSMatrix MinusMatrix( PtrTSMatrix A, PtrTSMatrix B )
{
	int i=0,j=0;//标记追逐 A  B 
	PtrTSMatrix C;//存放和

   if( A->rows!=B->rows || A->cols!=B->cols )
   {
	   return NULL;
   }
   
   C = ( PtrTSMatrix )malloc(sizeof( TSMatrix ));
   C->rows = A->rows;
   C->cols = A->cols;
   C->nums = -1; //初始化
   
   while( i<A->nums && j<B->nums )
   {
	   if( A->data[i].row*A->cols+A->data[i].col == B->data[j].row*B->cols+B->data[j].col )
	   {
		   if( A->data[i].value-B->data[j].value != 0 )
		   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value-B->data[j].value;
		   }
		   i++;
		   j++;//标记后移
	   }
	   else if( A->data[i].row*A->cols+A->data[i].col < B->data[j].row*B->cols+B->data[j].col )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
	   else
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }//if-else

   }//while,

   if( i == A->nums )
   {
	   while( j < B->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = B->data[j].col;
			 C->data[C->nums].row = B->data[j].row;
			 C->data[C->nums].value = B->data[j].value;
			 j++;
	   }
   }
   else 
   {
	   while( i < A->nums )
	   {
             C->nums++;
			 C->data[C->nums].col = A->data[i].col;
			 C->data[C->nums].row = A->data[i].row;
			 C->data[C->nums].value = A->data[i].value;
             i++;
	   }
   }//if-else

   C->nums++;

   return C;
}/* MiinusMatrix */


/* get the answer of A multiply B */
PtrTSMatrix MultiMatrix( PtrTSMatrix A, PtrTSMatrix B )
{
	PtrTSMatrix C;
    int num[MAXSIZE]={0};//第K行得非零元素得个数
	int cpot[MAXSIZE]={0};//k行得第一个非零元素在三元组得位置
	int i,j;
	int count = 0;
    int temp[MAXSIZE]={0};

	if( A->cols != B->cols )
	{
       return NULL;
	}//if ,输入检验

	C = (PtrTSMatrix)malloc( sizeof(TSMatrix) );
	C->rows = A->rows;
	C->cols = B->cols;

	for( i=0; i<B->nums; i++)
	{
        num[B->data[i].row-1]++;//m
		if( i!=0 && B->data[i-1].row!=B->data[i].row )
		{
            cpot[B->data[i-1].row-1] = i;
		}
	}

    for( i=0; i<A->nums; i++ )
	{
		if( i!=0 && A->data[i].row != A->data[i-1].row )
		{
               
			   for( j=0; j < B->cols; j++ )
			   {
				   if( temp[j] != 0 )
				   {
                      C->data[count].row = A->data[i-1].row;
					  C->data[count].col = j+1;
					  C->data[count].value = temp[j];
                     count++;
				   }
			   }//for,赋值
			   
			   for( j=0; j<B->cols; j++ )
			   {
				   temp[j] = 0;
			   }//for,初始化

		}//if

		for( j=0; j<num[A->data[i].col]; j++)
		{
			temp[ B->data[ cpot[A->data[i].col]+j ].col ]  = + A->data[i].value*B->data[ cpot[A->data[i].col]+j ];//高度注意，自己写一下
		}//for

	}//for
	
	return C;


}//MultiMatrix
int main(void)
{
   PtrTSMatrix A,B,C,D,E;
   A = CreatMatrix();
   B = CreatMatrix();
  
   C = AddMatrix( A, B );
   D = MinusMatrix( A , B );
   E = MultiMatrix( A, B );
   printf("\n");
   PrintMatrix( C );
   printf("\n");
   PrintMatrix( D );
   printf("\n");
   PrintMatrix( E );
   return 0;
}

　　

 

 

 

               

转载于:https://www.cnblogs.com/dilidingzhi/p/4028665.html

三次方程计算器
03-11
可快速计算三次方程，得出复数或实数解。
稀疏矩阵三元组的转置、相加和相乘
11-08
数据结构的作业，写的比较简单，也没有用类，算法比较容易理解，不过时间复杂度可能要差一些
稀疏矩阵的相乘和相加算法实现
05-13
改程序实现了稀疏矩阵的相乘和相加算法实现，算法简单，效率很高
稀疏矩阵的加法，减法和乘法
03-05
此程序实现了用三元组输入稀疏矩阵 并实现了稀疏矩阵的加法，减法和乘法。
稀疏矩阵.cpp 设计一个稀疏矩阵运算器。实现两个矩阵相加、相减和相乘等的运算。矩阵的输入输出均按通常的阵列形式
04-25
设计一个稀疏矩阵运算器。实现两个矩阵相加、相减和相乘等的运算。矩阵的输入输出均按通常的阵列形式
稀疏矩阵三元组计算器
最新发布
12-24
一个简单的稀疏矩阵三元组计算器可能包含以下功能： 1. **插入元素**：接收行、列和值，如果这个位置不在矩阵中，则创建新条目；如果已经在矩阵中，更新现有值。 ```cpp struct SparseMatrixTriple { int row; ...
稀疏矩阵计算器
08-09
根据给定的部分内容，可以看到程序设计采用了C语言，并定义了`TSMatrix`结构体来存储稀疏矩阵的信息，包括非零元素的三元组表示、行数、列数和非零元素的数量。通过`CreateSMatrix`函数创建矩阵，用户输入矩阵的尺寸...
稀疏矩阵运算器（C语言实现，代码完整，可读性很好）
06-27
1. 以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、 相减和相乘的运算。稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则 以通常的阵列形式列出。 2. 首先应输入矩阵的行数和列数，并...
高效稀疏矩阵计算器：实现三元组顺序运算
综上所述，稀疏矩阵及其相关运算在处理大规模数据时非常关键，三元组顺序表示法是一种高效的存储手段，而稀疏矩阵计算器则为实现稀疏矩阵的运算和结果输出提供了便捷的平台。通过专业的算法和优化，稀疏矩阵技术能够...
稀疏矩阵乘法加法等的java实现
weixin_30593261的博客
07-02 874
原创声明：本文系作者原创，转载请写明出处。 一、前言 前几天由于科研需要，一直在搞矩阵的稀疏表示的乘法，不过最近虽然把程序写出来了，还是无法处理大规模的矩阵（虽然已经是稀疏了）。原因可能是结果不够稀疏。或者相乘的矩阵本来也不稀疏。 还是把实现的程序放在这里。以供以后研究使用。 二、程序实现功能 首先封装稀疏...
POJ-3735-Training little cats-构造矩阵+矩阵快速幂+稀疏矩阵乘法优化
缺氧
10-26 712
http://poj.org/problem?id=3735 题意： n只猫，三种命令： 1、第i只猫吃掉所有花生； 2、第i只猫得到一个花生； 3、交换第i，j只猫的花生； 先由k个 这些命令组成一个操作序列 然后重复操作序列m次， n,k m的次数那么大，可以用构造矩阵，然后用快速幂的方法 引用大神http://blog.youkuaiyun.com/magicnumber/artic
稀疏矩阵的加法(用十字链表实现A=A+B)
comJason的博客
04-14 5785
描述： 输入两个稀疏矩阵A和B，用十字链表实现A=A+B，输出它们相加的结果。 输入： 第一行输入四个正整数，分别是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2，接下来的t1+t2行是三元组，分别是第一个矩阵的数据和第二个矩阵的数据, 三元组的第一个元素表示行,第二个元素表示列,第三个元素是该元素的值。 输出： 输出相加后的矩阵三元组。
稀疏矩阵的三元组表示的实现及应用（2）——采用三元组存储稀疏矩阵，设计两个稀疏矩阵相加的运算算法
热门推荐
Henry's Blog
10-30 1万+
/* *Copyright (c) 2015 , 烟台大学计算机学院 *All right resvered . *文件名称: 稀疏矩阵.cpp *作 者: 郑兆涵 *稀疏矩阵的三元组表示的实现及应用（2） */ 问题：稀疏矩阵的三元组表示的实现及应用 （2）采用三元组存储稀疏矩阵，设计两个稀疏矩阵相加的运算算法 提示1：两个行
以三元组表为存储结构实现矩阵相加
rain699的博客
04-04 5953
Description 假设稀疏矩阵A和B均以三元组表作为存储结构，试编写矩阵相加的程序，另设三元组表C存放结果矩阵。矩阵大小为m行n列 Input 第一行输入t1,t2,t1和t2分别是矩阵A和B中非零元素的个数，后面t1+t2行分别输入A和B中的元素，用三元组表示。 Output 输出三元组表C Sample Input 3 3 ...
算法----稀疏矩阵之三元组
weixin_30530523的博客
10-19 3789
三元组的表示 （1）、目的：对于在实际问题中出现的大型的稀疏矩阵，若用常规分配方法在计算机中储存，将会产生大量的内存浪费，而且在访问和操作的时候也会造成大量时间上的浪费，为了解决这一问题，从而善生了多种解决方案。 （2）、由于其自身的稀疏特性，通过压缩可以大大节省稀疏矩阵的内存代价。具体操作是：将非零元素所在的行、列以及它的值构成一个三元组（i,j,v），然后再按某种规律存储这些三元...
三元组稀疏矩阵类
goal00001111的专栏
05-07 2614
/*  Name: 三元组稀疏矩阵类  始发于goal00001111的专栏；允许自由转载，但必须注明作者和出处  Author: goal00001111  Date: 07-05-10 09:51  Description: 三元组稀疏矩阵类：实现了矩阵的转置，加法和乘法运算 */#include #include using namespace std;const int MAXTE
数据结构实践——稀疏矩阵相加
hgdfguj的博客
11-10 853
数据结构实践——稀疏矩阵相加
稀疏矩阵用三元数组表示后的矩阵乘法算法 集合！
喵帕斯 ♬
03-30 903
1 程序设计例子百科  http://programdesign.baike.com/article-379823.html  2 需要手动输入矩阵的例子  http://blog.sina.com.cn/s/blog_8a86f4dd0100zjxv.html  3  不需要输入自动显示的例子 
动态稀疏矩阵的两个三元组进行相加的算法
qq_38010909的博客
07-31 3817
动态稀疏矩阵的两个三元组进行相加的算法，其实在这里，我主要是写了加法操作，其实都可以进行加减乘除，算法都是一样的，我就不一一写出来了，但是我们要必须掌握其中之一的 算法就可以啦，那么其他的也就迎刃而解了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值