精华内容
下载资源
问答
  • 储存矩阵-源码

    2021-02-16 09:24:26
    关于Laravel Laravel是一个具有表达力,优雅语法的Web应用程序框架。 我们认为,发展必须是一种令人愉悦的创造力,才能真正实现。 Laravel通过减轻许多Web项目中使用的常见任务来减轻开发工作的痛苦,例如: ...
  • 记录一下用循环建立储存矩阵,或者是操作矩阵 为了之后的矩阵操作方便,数据类型都用为double,CV_64FC1 Mat x, y; meshgrid(Range(-s, s), Range(-s, s), y, x); Mat w = Mat::zeros(x.rows, x.cols, CV_64FC1); ...

    C++
    记录一下用循环建立储存矩阵,或者是操作矩阵

    为了之后的矩阵操作方便,数据类型都用为double,CV_64FC1
    Mat x, y;
    meshgrid(Range(-s, s), Range(-s, s), y, x);
    Mat w = Mat::zeros(x.rows, x.cols, CV_64FC1);
    for (int i = 0; i < x.rows; i++)
    {
    for (int j = 0; j < x.cols; j++)
    {
    double a,b;
    a = x.at(i, j) * x.at(i, j) + y.at(i, j) * y.at(i, j);
    b = exp(-a / (2 * sigma * sigma));
    w.at(i, j) = b;

    	}
    }
    

    今天还学到一个新词 :ROI区域:感兴趣区域

    定义ROI的方式:

    1.是指定感兴趣行或列的范围Range,从开始索引到终止索引(但不包括终止)的一连段连续序列。
    eg.
    imageROI=image(Range(250,250+logoImage.rows),Range(200,200+logoImage.cols))

    2.使用表示矩形区域的Rect.
    eg.
    imageROI=image(Rect(500,250,logo.cols,logo.rows)
    cols指的是列数,rows指的是行数。

    展开全文
  • 问题描述:用压缩形式存储对称矩阵,实现下面的操作并测试 void Init(int *&b);//为N阶对称矩阵初始化存储数据的一维数组b int Value(int b[], int i, int j);//返回存储在b[M]中,对应二维数组A[i][j]的值 void ...
    /     
    作    者:孙子策 
    完成日期:2016.10.26
    问题描述:用压缩形式存储对称矩阵,实现下面的操作并测试 
    void Init(int *&b);//为N阶对称矩阵初始化存储数据的一维数组b 
    int Value(int b[], int i, int j);//返回存储在b[M]中,对应二维数组A[i][j]的值 
    void Assign(int b[], int e, int i, int j);//将e赋值给对应二维数组元素A[i][j],要存储到b[M]中 
    void Disp(int b[]);//输出压缩存储在b中的对称矩阵 
    void Destroy(int b[]); //销毁存储空间 
    /  

    #include<stdio.h>  
    #include<malloc.h>  
    #define N 4  
    void Init(int *&b)//为N阶对称矩阵初始化存储数据的一维数组b  
    {  
        b=(int *)malloc(sizeof(int)*(N*(N+1)/2));  
      
    }  
    int Value(int b[], int i, int j)//返回存储在b[M]中,对应二维数组A[i][j]的值  
    {  
        if(i>=j)  
            return b[(i*(i+1))/2+j];  
        else  
            return b[(j*(j+1))/2+i];  
    }  
    void Assign(int b[], int e, int i, int j)//将e赋值给对应二维数组元素A[i][j],要存储到b[M]中  
    {  
        if(i>=j)  
            b[(i*(i+1))/2+j] = e;  
        else  
            b[(j*(j+1))/2+i] = e;  
        return ;  
    }  
    void Disp(int b[])//输出压缩存储在b中的对称矩阵  
    {  
         int i,j;  
        for (i=0; i<N; i++)  
        {  
            for (j=0; j<N; j++)  
                printf("%4d",Value(b,i,j));  
            printf("\n");  
        }  
    }  
    void Destroy(int b[]) //销毁存储空间  
    {  
        free(b);  
    }  
    int main()  
    {  
        int *b1;  //指向整型的指针,待初始化  
        int i, j;  
        int v;  
        Init(b1);  
        printf("请输入对称矩阵(只需要输入下三角部分即可)\n");  
        for(i=0;i<N;i++)  
        {  
            printf("输入第%d行的%d个数据元素: ", i+1, i+1);  
            for(j=0; j<=i; j++)  
            {  
                 scanf("%d", &v);  
                 Assign(b1, v, i, j);  
            }  
        }  
        Disp(b1);  
        Destroy(b1);  
        return 0;  
    }  

    知识点总结:

    利用上三角和下三角。

    心得体会:

    还是要记住公式。

    展开全文
  • 矩阵压缩储存

    2020-10-01 01:04:14
    我们感兴趣的不是矩阵本身而是如何储存矩阵的元,从而使矩阵的各种运算能够有效地进行。 矩阵压缩需要矩阵具有某些相同的元素或者零元素,假若值相同的元素或者零元素在矩阵中的分布具有一定规律,则我们称此类矩阵...

    矩阵压缩储存

    矩阵是许多科学与工程计算问题中研究的数学对象。我们感兴趣的不是矩阵本身而是如何储存矩阵的元,从而使矩阵的各种运算能够有效地进行。
    矩阵压缩需要矩阵具有某些相同的元素或者零元素,假若值相同的元素或者零元素在矩阵中的分布具有一定规律,则我们称此类矩阵为特殊矩阵;反之,成为稀疏矩阵。下面分别讨论他们的压缩储存。

    特殊矩阵

    对称矩阵若n阶矩阵A中的元满足

    aij=aji 1i,jna_{ij}=a_{ji}\ 1\le i,j\le n

    则称为n阶对称矩阵。
    显然我们可以折半储存,每一对只存一次,对于主对角线对称的矩阵我们储存其下三角(包括对角线)中的元。我们用sa[n(n+1)/2]sa[n(n+1)/2]作为n阶对称矩阵A的储存结构,则sa[k],aijsa[k],a_{ij}之间存在着一一对应的关系。

    k={i(i1)2+j1 ijj(j1)2+i1 jik=\begin{cases} \frac{i(i-1)}{2}+j-1\ 当i\ge j\\ \\ \frac{j(j-1)}{2}+i-1\ 当j\ge i \end{cases}

    a11a_{11} a21a_{21} a22a_{22} a31a_{31} \cdots an,1a_{n,1} \cdots an,na_{n,n}

    对角线矩阵所有的非零元素都集中在以主对角线为中心的带状区域中。对于这种的矩阵我们也可以按照某一原则将其压缩到一维数组上。
    在这里插入图片描述

    k={2i+j3 0 k=\begin{cases} 2*i+j-3\ 当点在对角带中\\ \\ 0\ 当点不在对角带中 \end{cases}

    a11a_{11} a12a_{12} a21a_{21} a22a_{22} a23a_{23} \cdots an,n1a_{n,n-1} an,na_{n,n}

    这些特殊矩阵中非零元素的分布都具有一定明显的规律,所以我们可以将其压缩到一个一维数组中,并找到对应关系。

    稀疏矩阵

    在实际应用中我们还经常遇到另一类矩阵,其非零元素较零元素少,且分布没有一定规律,我们称之为稀疏矩阵。
    人们无法给出准确的定义,它只是一个凭人们的直觉来了解的概念。假设在mnm*n的矩阵中,有t个元素不为零。令δ=tmn\delta=\frac{t}{m*n},称δ\delta为矩阵的稀疏因子。通常认为δ0.05\delta\le0.05时称为稀疏矩阵。
    三元组顺序表我们可以以顺序储存结构来表示三元组表,则可得稀疏矩阵的一种压缩方式。

    typedef struct {
    	int i, j;
    	int e;
    }Triple;//三元组的数据结构
    typedef struct {
    	Triple data[MAX + 1];//非零三元组表
    	int mu, nu, tu;//矩阵的行数、列数和非零元的个数
    }TSMatrix;
    

    注意:为了还原数组需要记录原数组的行,列数。非零元个数是为了方便运算。
    在此的非零元三元组是以行序为主序顺序排列的,我们会再后面看出这样做将有利于进行某种矩阵运算。
    转置运算
    朴素算法:(1)将矩阵的行列值相互交换;
    (2)将每个元组中的i和j相互调换;
    (3)重排三元组之间的次序便可实现矩阵的转置。
    代码略。
    搜索算法:根据转置后的三元组顺序寻找三元组转置。换句话说,按照矩阵M的列序来进行转置。为了找到M的每一列中所有的非零元素,需要对原三元组表从第一行起整个扫描一遍,由于原三元表是以M为行序为主序来存放每个非零元的,所以由此得到的恰好是转置后的应有的顺序。

    void TransposeSMAtrix(TSMatrix M, TSMatrix &T) {
    	T.mu = M.nu, T.nu = M.mu, T.tu = M.tu;
    	if (T.tu) {
    		int q = 1;
    		for(int col=1;col<=M.nu;col++)
    			for(int p=1;p<=M.tu;p++)
    				if (M.data[p].j == col) {
    					T.data[q].i = M.data[p].j;
    					T.data[q].j = M.data[p].i;
    					T.data[q].e = M.data[p].e;
    					q++;
    				}
    	}
    	return;
    }
    

    我们知道一般矩阵的直接求转置矩阵时间复杂度是OmunuO(mu*nu)
    上面的算法主要是col与p的两层循环,当矩阵的非零元个数tu与munumu*nu同数量级时,算法的时间复杂度就成了O(munu2)O(mu*nu^2),所以上面算法只适用于tumunutu\ll mu*nu的情况。
    转置高效算法
    按照原矩阵的三元组的次序进行转置,并将转置后的三元组置入b中恰当的位置。如果能预先确定矩阵M中的每一列的第一个非零元素在b.datab.data中应有的位置,那么在对a.dataa.data中的三元组依次转置时,便可直接放到b.datab.data中恰当的位置上去。为了确认这些位置,在转置前,应先求得M的每一列中非零元的个数,进而求得每一列中非零元的个数,进而求得每一列的第一个非零元在b.datab.data中应有的位置。
    在此,需要附设num和cpot两个数组。num[col]num[col]表示矩阵M中第col列中非零元的个数,cpot[col]cpot[col]指示M中第col列的一个非零元在b.datab.data中的恰当位置。有

    {cpot[1]=1;cpot[col]=cpot[col1]+num[col1] 2cola.nu\begin{cases} cpot[1]=1;\\ cpot[col]=cpot[col-1]+num[col-1]\ 2\le col\le a.nu \end{cases}

    void FastTransposeSMatrix(TSMatrix M, TSMatrix&T) {
    	T.mu = M.nu, T.nu = M.mu, T.tu = M.tu;
    	if (T.tu) {
    		for (int col = 1; col <= M.nu; col++)num[col] = 0;
    		for (int t = 1; t <= M.tu; t++)num[M.data[t].j]++;
    		cpot[1] = 1;
    		for (int col = 2; col <= M.nu; col++)cpot[col] = cpot[col - 1] + num[col - 1];
    		for (int p = 1; p <= M.tu; p++) {
    			int col = M.data[p].j;
    			int q = cpot[col];
    			T.data[q].i = M.data[p].j;
    			T.data[q].j = M.data[p].j;
    			T.data[q].e = M.data[p].e;
    			cpot[col]++;
    		}
    	}
    }
    

    这个算法仅比前一个算法多用了两个辅助数组,从时间复杂度上看算法中有四个单循环,循环次数分别是nu,tu因而总的时间复杂度是O(nu+tu)O(nu+tu)在非零元素tu与numunu*mu同一数量级时,其时间复杂度为O(munu)O(mu*nu),和经典算法相同。
    矩阵乘法
    经典算法是使用二维数组实现矩阵乘法。

    for(i=1;i<=m1;++i)
    	for(j=1;j<=n2;++j){
    		Q[i][j]=0;
    		for(k=1;k<=n1;++k)Q[i][j]+=M[i][k]*N[k][j];
    	}
    

    此算法的时间复杂度是O(m1n1n2)O(m_1*n_1*n_2)
    那如果使用顺序三元组如何实现矩阵乘法呢?
    我们想要得到的数组也用顺序三元组表示,这就要利用原本三元组的顺序,每次取M数组的j,找到对应的N数组的i,相乘累加到暂存数组中。待一行的乘积和都完成后按顺序存储。最终就得到了顺序三元组。

    void MultSMatrix(RLSMatrix M, RLSMatrix N, RLSMatrix &Q) {
    	int ctemp[MAX];
    	int tp, t, ccol;
    	if (M.nu != N.mu) { cout << "错误" << endl; return; }
    	Q.nu = M.nu; Q.mu = N.mu; Q.tu = 0;
    	if (M.tu*N.tu != 0) {
    		for (int arow = 1; arow <= M.mu; arow++) {
    			memset(ctemp, 0, sizeof(ctemp));
    			Q.rpos[arow] = Q.tu + 1;
    			if (arow < M.mu)tp = M.rpos[arow + 1];
    			else tp = M.tu + 1;
    			for (int p = M.rpos[arow]; p < tp; p++) {
    				int brow = M.data[p].j;
    				if (brow < N.mu)t = N.rpos[brow + 1];
    				else t = N.tu + 1;
    				for (int q = N.rpos[brow]; q < t; q++) {
    					ccol = N.data[q].j;
    					ctemp[ccol] += M.data[p].e*N.data[q].e;
    				}
    			}
    			for (ccol = 1; ccol <= Q.nu; ccol++) {
    				if (++Q.tu > MAX) { cout<<"错误"<<endl; return; }
    				Q.data[Q.tu] = { arow, ccol, ctemp[ccol] };
    			}
    		}
    	}
    }
    

    M数组m行n列,N数组是n行p列,则算法总复杂度是O(mp)O(m*p),这显然非常高效。

    十字链表

    当矩阵的非零元个数和的个数和位置在操作过程中变化太大时,就不宜采用顺序储存结构来表示三元组的线性表。例如将一个矩阵加到另一个矩阵上的操作时,由于非零元的删除或插入将会引起三元组表中的元素的移动。为此,对于这种类型的矩阵,我们可以使用链表储存。
    如果只需要列遍历或行遍历可以使用邻接链表储存,但如果既要列遍历又要行遍历就需要使用十字链表,储存两个索引分别指向行与列。
    在这里插入图片描述

    void CreateSMatrix_OL(CrossList &M){
    	int m, n, t;
    	cin >> m >> n >> t;
    	M.mu = m; M.nu = n; M.tu = t;
    	M.rhead = new OLink;
    	M.chead = new OLink;
    	M.rhead = M.chead = NULL;
    	int i, j, e;
    	for (cin >> i >> j >> e; i != 0; cin >> i >> j >> e) {
    		OLink p = new OLNode;
    		OLink q = new OLNode;
    		p->i = i; p->j = j; p->e = e;
    		if (M.rhead[i] == NULL || M.rhead[i]->j > j) {
    			p->right = M.rhead[i]; M.rhead[i] = p;
    		}
    		else {
    			for (q = M.rhead[i]; (q->right) && q->right->j < j; q = q->right);
    			p->right = q->right; q->right = p;
    		}
    		if (M.chead[j] == NULL || M.chead[j]->i > i) {
    			p->down = M.chead[j]; M.chead[j] = p;
    		}
    		else {
    			for (q = M.chead[j]; (q->down) && q->down->i < i; q = q->down);
    			p->down = q->down; q->down = p;
    		}
    	}
    }
    

    对于m行n列且有t个非零元的稀疏矩阵,算法的时间复杂度是O(ts),s=max(m,n)O(t*s),s=max(m,n),这是因为每建立一个非零元的结点时都要寻找他在行表和列表中的插入位置,此算法对于非零元输入的先后顺序没任何要求。反之,若按照行序为主序的次序依次输入三元组,则可将建立十字链表的算法改写成O(t)O(t)的数量级的(t为非零元的个数)。
    将一个矩阵加到另一个矩阵与构建矩阵的算法类似。

    展开全文
  • 十字链表储存稀疏矩阵矩阵相乘

    千次阅读 2016-11-03 09:28:11
    在进行矩阵的加法、减法和乘法等运算时,用十字链表表示稀疏矩阵比用三元组表示更灵活,以下为结构图和代码
       

    在进行矩阵的加法、减法和乘法等运算时,用十字链表表示稀疏矩阵比用三元组表示更灵活,以下为结构图和代码



    /*  十字链表的结构类型
    */
    typedef int ElemType;
    typedef struct OLNode{
      int row,col;
      ElemType value;
      struct OLNode *right,*down;
    }OLNode,*OLink;
    
    typedef struct{
       OLink *row_head,*col_head;
       int m,n,len;
    }CrossList;
    /*建立三元稀疏矩阵
      1、读入稀疏矩阵的行、列、非零元素的个数
      2、动态申请行、列链表的头指针向量
      3、逐个读入非零元素,分别插入行链表、列链表
    */
    int CreateCrossList(CrossList *s){
       int k,m,n,t,i,j;
    
       ElemType e;
       OLNode *p=NULL,*q=NULL;
       printf("Input m,n,t of CrossList:\n");
       scanf("%d %d %d ",&m,&n,&t);
       s->m=m;s->n=n;s->len=t;
       s->row_head=(OLNode *)malloc((m+1)*sizeof(OLNode));
       if(s->row_head==NULL){
          printf("行头指针创建失败\n");
       }
       s->col_head=(OLNode *)malloc((n+1)*sizeof(OLNode));
    
       if(s->col_head==NULL){
          printf("列头指针创建失败\n");
       }
       for(i=1;i<=s->m;i++){
          s->row_head[i]=NULL;
       }
       for(i=1;i<=s->n;i++){
         s->col_head[i]=NULL;
       }
       scanf("%d %d %d ",&k,&j,&e);
       while(k!=0){
        if(!(p=(OLNode *)malloc(sizeof(OLNode)))){
           printf("内存不足");
        }
        p->row=k;p->col=j;p->value=e;
        p->right=NULL;p->down=NULL;
        if(s->row_head[k]==NULL){
            s->row_head[k]=p;
        }else{
            for(q=s->row_head[k];q->right&&q->right->col<j;q=q->right);
            //p->right=q->right;
            q->right=p;
        }
        if(s->col_head[j]==NULL){
           s->col_head[j]=p;
        }else{
            for(q=s->col_head[j];q->down&&q->down->row<k;q=q->down);
            //p->down=q->down;
            q->down=p;
        }
       scanf("%d %d %d ",&k,&j,&e);
       }
       return 0;
    }

    
    
    
           矩阵相乘基本思路是,遍历每一行的元素和查找相应的矩阵对应元素,假如有则相乘,无则置零。查找方法是先找到行指针,遍历根据相应列指针直至找到对应元素或遍历到底置零。
    


    以下为代码

    /*  */
    #include<stdio.h>
    /*  十字链表的结构类型
    */
    typedef int ElemType;
    typedef struct OLNode{
      int row,col;
      ElemType value;
      struct OLNode *right,*down;
    }OLNode,*OLink;
    
    typedef struct{
       OLink *row_head,*col_head;
       int m,n,len;
    }CrossList;
    /*建立三元稀疏矩阵
      1、读入稀疏矩阵的行、列、非零元素的个数
      2、动态申请行、列链表的头指针向量
      3、逐个读入非零元素,分别插入行链表、列链表
    */
    int CreateCrossList(CrossList *s){
       int k,m,n,t,i,j;
       ElemType e;
       OLNode *p=NULL,*q=NULL;
       printf("Input m,n,t of CrossList:\n");
       scanf("%d %d %d",&m,&n,&t);
       s->m=m;s->n=n;s->len=t;
       s->row_head=(OLNode *)malloc((m+1)*sizeof(OLNode));
       if(s->row_head==NULL){
          printf("行头指针创建失败\n");
       }
       s->col_head=(OLNode *)malloc((n+1)*sizeof(OLNode));
    
       if(s->col_head==NULL){
          printf("列头指针创建失败\n");
       }
       for(i=1;i<=s->m;i++){
          s->row_head[i]=NULL;
       }
       for(i=1;i<=s->n;i++){
         s->col_head[i]=NULL;
       }
    
      for(i=1;i<=t;i++){
          scanf(" %d %d %d",&k,&j,&e);
        if(!(p=(OLNode *)malloc(sizeof(OLNode)))){
           printf("内存不足");
        }
        p->row=k;p->col=j;p->value=e;
        p->right=NULL;p->down=NULL;
        if(s->row_head[k]==NULL){
            s->row_head[k]=p;
        }else{
            for(q=s->row_head[k];q->right&&q->right->col<j;q=q->right);
            //p->right=q->right;
            q->right=p;
        }
        if(s->col_head[j]==NULL){
           s->col_head[j]=p;
        }else{
            for(q=s->col_head[j];q->down&&q->down->row<k;q=q->down);
            //p->down=q->down;
            q->down=p;
        }
    
       }
       return 0;
    }
    //打印十字链表
    int showCrossList(CrossList *s){
       int i;
       OLNode *p=NULL;
       for(i=1;i<=s->m;i++){
           p=s->row_head[i];
           while(p!=NULL){
                printf("%d ",p->value);
                p=p->right;
           }
           printf("\n");
       }
    }
    /*矩阵相乘
      以q行指针遍历每一行,并判断相应的L列指针上是否有值,假如有,相乘
    */
    int multiCrossList(CrossList *s,CrossList *p){
        OLNode *q=NULL,*L=NULL;
        int i,num;
        if(s->n==p->m){
           for(i=1;i<=s->m;i++){
              q=s->row_head[i];
              while(q!=NULL){
                 num=0;
                 L=p->row_head[q->col];
                 if(L==NULL){
                   num+=0;
                 }else{
                   if(p->col_head[q->row]==NULL){
                      num+=0;
                   }else{
                       for(;L->right&&L->right==p->col_head[q->row];L=L->right);
                       if(L==NULL){
                           num+=0;
                       }else{
                           num=num+L->value*q->value;
                       }
                   }
                 }
                 q->value+=num;
                 q=q->right;
              }
           }
        }else{
          printf("矩阵无法相乘");
        }
    }
    int main(){
         CrossList *s=(CrossList *)malloc(sizeof(CrossList));
         CrossList *p=(CrossList *)malloc(sizeof(CrossList));
         CreateCrossList(s);
         CreateCrossList(p);
         multiCrossList(s,p);
         showCrossList(s);
    }
    



    展开全文
  • ②把邻接表储存转化为邻接矩阵储存 ③输出邻接矩阵 思路:转化分两步,一个是顶点数组,一个是邻接矩阵。顶点数组直接循环邻接表的顶点数组赋值,邻接矩阵则需要对每一个顶点结点的FirstArc进行判断,如果不是NULL就...
  • 三、对称矩阵的压缩储存: 压缩存储称矩阵存储时只需要存储上三角/下三角的数据,所以最多存储n(n+1)/2个数据(相当于1+2+…+n,即等差数列求和)。 对称矩阵和压缩存储的对应关系:下三角存储i>=j, SymmetricMatrix...
  • 储存器山和矩阵乘法

    2020-05-03 13:25:37
    博客简介 关于cache的性能,影响因素由很多。固有的cache大小即cache组规模会影响cache的性能,这由计算机内部硬件属性决定。而对于编码者来说,可以考虑编写对Cache友好的代码,提高空间局部...矩阵乘法的例子则考...
  • 前言:什么是稀疏矩阵: 一个M*N(即M行N列)的矩阵矩阵中有效值的个数远小于无效值的个数,且这些数据的分布没有规律。 例如:一个6行5列的稀疏矩阵(M = 6,N = 5) ...一、稀疏矩阵的压缩储存
  • 对称矩阵的压缩储存

    千次阅读 2017-04-18 18:11:25
    一、存储矩阵用一个二维数组即可; 二、什么是对称矩阵: 设一个N*N的方阵A,A中任意...三、对称矩阵的压缩储存: 压缩存储称矩阵存储时只需要存储上三角/下三角的数据,所以最多存储n(n+1)/2个数据(相当于1+2+
  • 邻接矩阵储存无向图

    2018-09-01 17:06:04
    采用邻接矩阵实现无向图的存储,并输入输出邻接矩阵。实现图的广度优先遍历和深度优先遍历。
  • n次循环每次产生1行3列矩阵,将这些矩阵储存在一个n行3列的矩阵中 for i = 1:length(Vector_X) u_X = Vector_X(i,:)/norm(Vector_X(i,:)); %将第一行的单位向量赋值给u_X U_X(i,:) = u_X; %将u_X的值赋值给U_X的...
  • 下面我们直接看矩阵储存,一般情况下,矩阵使用二维数组储存的,但是,对于数据量非常大的矩阵,这样储存就显得乏力了,又浪费空间资源,下面我们就看看有没有更好的储存方法呢。很明显,我们可以用一位数组压缩...
  • 基于三元组表储存稀疏矩阵求鞍点 数据结构课 #include<stdio.h> #include<stdlib.h> #define Maxsize 10 typedef struct{ //定义三元组表 int i,j; int v; }TriTupleNode; typedef struct{ //...
  • 稀疏矩阵

    2017-07-13 17:26:24
    稀疏矩阵 如果在矩阵中,多数的元素并没有资料,称此矩阵为稀疏矩阵,由于矩阵在程序中常用二维...介绍:整列只储存矩阵的行数,列数与有资料的索引位置及其值,在需要使用矩阵资料时,再透过程式  运算加以还原,例

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,225
精华内容 490
关键字:

储存矩阵