精华内容
下载资源
问答
  • 十字链表存储稀疏矩阵
    千次阅读
    2021-11-23 10:29:03

      对于矩阵的存储,如果矩阵的元素呈有明显规律的排列的话,我们一般用一个一维数组对矩阵进行压缩存储;若矩阵中的元素多数为0,只有少数的元素为非0元素时,我们成该矩阵为稀疏矩阵
    我 们 有 矩 阵 A i j , 其 中 有 非 0 元 素 m 个 , 若 m i j ≤ 0.05 , 则 我 们 称 矩 阵 A i j 为 稀 疏 矩 阵 我们有矩阵A_{ij},其中有非0元素m个,若\frac{m}{ij} \le 0.05,则我们称矩阵A_{ij}为稀疏矩阵 Aij0mijm0.05Aij
      对于稀疏矩阵,因为非零元素的排列是没有规律的,因此我们无法采用压缩的方法存储矩阵,而若用一个二维数组去存储含有为数不多的非零元素的矩阵,会有大量的空间浪费在存储毫无意义的0元素上,因此,对于稀疏矩阵,我们可以选择用十字链表来存储。

    话不多说,先上代码

    #include<stdio.h>
    #include<stdlib.h>
    #define FALSE 0
    #define TRUE 1
    
    
    typedef int DataType;
    typedef struct SNode
    {
    	int row;
    	int column;
    
    	union
    	{
    		DataType value;
    		struct SNode *next;
    	}uval;
    
    	struct SNode *rnext;
    	struct SNode *cnext;
    }SNode, *SNodePtr;
    
    
    // 创建矩阵
    DataType **
    CreateMatrix(int row, int column);
    
    // 创造十字链表
    SNodePtr
    Create(int row, int column);
    
    // 向十字链表插入(如果存在则相加)
    void
    Insert(SNodePtr phead, SNodePtr pnode);
    
    // 将稀疏矩阵转换成十字链表存储
    SNodePtr
    Matrix2List(DataType **pparr, int row, int column);
    
    // 矩阵相加
    SNodePtr
    MatrixAdd(SNodePtr phead1, SNodePtr phead2);
    
    // 打印矩阵
    void
    Print(SNodePtr phead);
    
    
    int main()
    {
    	printf("请输入第一个矩阵\n");
    	DataType **arr1 = CreateMatrix(4, 4);
    	printf("\n\n请输入第二个矩阵\n");
    	DataType **arr2 = CreateMatrix(4, 4);
    
    	SNodePtr phead1 = Matrix2List(arr1, 4, 4);
    	SNodePtr phead2 = Matrix2List(arr2, 4, 4);
    
    	printf("\n\n\n");
    	// 打印两个矩阵
    	Print(phead1);
    	printf("\n\n\n");
    	Print(phead2);
    	printf("\n\n\n");
    
    	SNodePtr phead = MatrixAdd(phead1, phead2);
    	Print(phead);
    	return 0;
    }
    
    
    // 创建矩阵
    DataType **
    CreateMatrix(int row, int column)
    {
    	DataType **ipparr = (int **)malloc(sizeof(int *) * row);
    
    	for(int i = 0; i < row; ++i)
    	{
    		ipparr[i] = (int *)malloc(sizeof(int) * column);
    		for(int j = 0; j < column; ++j)
    			scanf("%d", &ipparr[i][j]);
    	}
    	return ipparr;
    }
    
    // 创造十字链表
    SNodePtr
    Create(int row, int column)
    {
    	// 创建头结点
    	SNodePtr phead = (SNodePtr)malloc(sizeof(SNode));
    	phead->row = row;
    	phead->column = column;
    	phead->rnext = phead->cnext = NULL;
    	phead->uval.next = NULL;
    	SNodePtr ptmp = phead;
    
    	// 创建十字链表
    	if(row > column)
    	{
    		for(int i = 0; i < row; ++i)
    		{
    			ptmp->uval.next = (SNodePtr)malloc(sizeof(SNode));
    			ptmp = ptmp->uval.next;
    			ptmp->row = ptmp->column = 0;
    			ptmp->uval.next = NULL;
    			ptmp->cnext = ptmp;
    			if(i < column)
    				ptmp->rnext = ptmp;
    			else 
    				ptmp->rnext = NULL;
    		}
    	}
    	else
    	{
    		for(int i = 0; i < column; ++i)
    		{
    			ptmp->uval.next = (SNodePtr)malloc(sizeof(SNode));
    			ptmp = ptmp->uval.next;
    			ptmp->row = ptmp->column = 0;
    			ptmp->uval.next = NULL;
    			ptmp->rnext = ptmp;
    			if( i < row)
    				ptmp->cnext = ptmp;
    			else
    				ptmp->cnext = NULL;
    		}
    	}
    	return phead;
    }
    
    // 向十字链表插入(如果存在则相加)
    void
    Insert(SNodePtr phead, SNodePtr pnode)
    {
    	SNodePtr prtmp = phead;
    	// 找到对应行
    	for(int i = 0; i < pnode->row; ++i)
    		prtmp = prtmp->uval.next;
    
    	SNodePtr ptmp1 = prtmp;
    	// 找到要插入的地方
    	while(ptmp1->cnext != prtmp && ptmp1->cnext->column < pnode->column)
    		ptmp1 = ptmp1->cnext;
    
    	if(ptmp1->cnext->column !=  pnode->column)		
    	{
    		SNodePtr ptmp = (SNodePtr)malloc(sizeof(SNode));		// 新开辟空间使为了不改变pnode的指针
    		ptmp->cnext = ptmp1->cnext;
    		ptmp1->cnext = ptmp;
    		ptmp->column = pnode->column;
    		ptmp->row = pnode->row;
    		ptmp->uval.value = pnode->uval.value;
    		ptmp->rnext = NULL;
    
    		// 接下来要将行指针连接
    		SNodePtr pctmp = phead;
    		// 找到对应列
    		for(int i = 0; i < pnode->column; ++i)
    			pctmp = pctmp->uval.next;
    
    		SNodePtr ptmp2 = pctmp;
    		// 找到要插入的地方
    		while(ptmp2->rnext != pctmp && ptmp2->rnext->row < pnode->row)
    			ptmp2 = ptmp2->rnext;
    		ptmp->rnext = ptmp2->rnext;
    		ptmp2->rnext = ptmp;
    		return ;
    	}
    	else		// 这一行有非零元素且他们在同一列
    	{
    		ptmp1->cnext->uval.value += pnode->uval.value;
    		return ;		// 因为没有开辟新的空间,原来的结构不变,因此不需要对列进行操作,直接返回即可
    	}
    
    }
    
    	
    
    // 将稀疏矩阵转换成十字链表存储
    SNodePtr
    Matrix2List(DataType **pparr, int row, int column)
    {
    	SNodePtr phead = Create(row, column);		// 创建十字链表
    
    	// 创建并初始化临时指针
    	SNodePtr ptmp = (SNodePtr)malloc(sizeof(SNode));
    	ptmp->row = ptmp->column = 0;
    	ptmp->uval.value = 0;
    	ptmp->rnext = ptmp->cnext = NULL;
    
    	for(int i = 0; i < row; ++i)
    	{
    		for(int j = 0; j < column; ++j)
    		{
    			if(pparr[i][j] != 0)
    			{
    				ptmp->row = i + 1;
    				ptmp->column = j + 1;
    				ptmp->uval.value = pparr[i][j];
    				Insert(phead, ptmp);
    			}
    		}
    	}
    	return phead;
    }
    
    
    // 矩阵相加
    SNodePtr
    MatrixAdd(SNodePtr phead1, SNodePtr phead2)
    {
    	if(phead1->row != phead2->row || phead1->column != phead2->column)		// 矩阵无法相加
    		return NULL;
    
    	SNodePtr phead = Create(phead1->row, phead1->column);
    
    	// 将phead1加入phead
    	SNodePtr ptmp = phead1;
    	for(int i = 0; i < phead1->row; ++i)
    	{
    		ptmp = ptmp->uval.next;
    		SNodePtr ptmp2 = ptmp;
    		while(ptmp2->cnext != ptmp)
    		{
    			ptmp2 = ptmp2->cnext;
    			Insert(phead, ptmp2);
    		}
    	}
    
    	Print(phead);
    
    	// 将phead2加入phead
    	ptmp = phead2;
    	for(int i = 0; i < phead2->row; ++i)
    	{
    		ptmp = ptmp->uval.next;
    		SNodePtr ptmp2 = ptmp;
    		while(ptmp2->cnext != ptmp)
    		{
    			ptmp2 = ptmp2->cnext;
    			Insert(phead, ptmp2);
    		}
    	}
    
    	return phead;
    }
    
    // 打印矩阵
    void
    Print(SNodePtr phead)
    {
    	SNodePtr prtmp = phead;
    	for(int i = 0; i < phead->row; ++i)
    	{
    		prtmp = prtmp->uval.next;
    		SNodePtr pctmp = prtmp->cnext;
    		if(pctmp == prtmp)
    		{
    			printf("0 0 0 0 ");
    			continue;
    		}
    
    		for(int j = 1; j <= pctmp->column; ++j)
    		{
    			if(j < pctmp->column)
    				printf("0 ");
    			else
    			{
    				printf("%d ", pctmp->uval.value);
    				pctmp = pctmp->cnext;
    				if(pctmp == prtmp)
    				{
    					for(int k = phead->column; k > j; --k)
    						printf("0 ");
    					break;
    				}
    			}
    		}
    		printf("\n");
    	}
    	printf("\n");
    }
    
    

      我的基本思想是对于矩阵的操作是不会影响原矩阵,即A + B = C,C不是将A加入B或者B加入A得到的,而是新开辟的一块空间。基于此思想,在进行插入操作的时候,我并没有对待插入的结点的指针做任何转变,而是找到要插入的位置,新开辟一块空间,将待插入结点的值,行列等赋值给新开辟的空间,然后再连接插入的结点的行列指针即可。基于此思想,我们在执行矩阵A和B的相加的时候,完全不用考虑矩阵A和矩阵B中指针的变动,只需要创建一个新的空的十字链表,然后将A和B中的元素插入即可。

    更多相关内容
  • 十字链表存储稀疏矩阵算法,实现两个矩阵的乘法运算
  • 实验6:稀疏矩阵十字链表的存储.pdf
  • 实现了从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵十字链表存储结构(m、n分别表示矩阵行数和列数;i, j为非零元素行号和列号)和十字链表的转置并将转置后的三元组到另一字符文件中
  • 对于压缩存储稀疏矩阵,无论是使用三元组顺序,还是使用行逻辑链接的顺序,归根结底是使用数组存储稀疏矩阵。介于数组 “不利于插入和删除数据” 的特点,以上两种压缩存储方式都不适合解决类似 “向矩阵中添加...

    原文链接:http://data.biancheng.net/view/186.html

    对于压缩存储稀疏矩阵,无论是使用三元组顺序表,还是使用行逻辑链接的顺序表,归根结底是使用数组存储稀疏矩阵。介于数组 “不利于插入和删除数据” 的特点,以上两种压缩存储方式都不适合解决类似 “向矩阵中添加或删除非 0 元素” 的问题。
    例如,A 和 B 分别为两个矩阵,在实现 “将矩阵 B 加到矩阵 A 上” 的操作时,矩阵 A 中的元素会发生很大的变化,之前的非 0 元素可能变为 0,而 0 元素也可能变为非 0 元素。对于此操作的实现,之前所学的压缩存储方法就显得力不从心。
    本节将学习用十字链表存储稀疏矩阵,该存储方式采用的是 “链表+数组” 结构,如图 1 所示。
    在这里插入图片描述

    图 1 十字链表示意图

    可以看到,使用十字链表压缩存储稀疏矩阵时,矩阵中的各行各列都各用一各链表存储,与此同时,所有行链表的表头存储到一个数组(rhead),所有列链表的表头存储到另一个数组(chead)中。
    因此,各个链表中节点的结构应如图 2 所示:
    在这里插入图片描述

    图 2 十字链表的节点结构

    两个指针域分别用于链接所在行的下一个元素以及所在列的下一个元素。

    链表中节点的 C 语言代码表示应为:

    typedef struct OLNode{
        int i,j;//元素的行标和列标
        int data;//元素的值
        struct OLNode * right,*down;//两个指针域
    }OLNode;
    

    同时,表示十字链表结构的 C 语言代码应为:

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct OLNode
    {
        int i, j, e; //矩阵三元组i代表行 j代表列 e代表当前位置的数据
        struct OLNode *right, *down; //指针域 右指针 下指针
    }OLNode, *OLink;
    typedef struct
    {
        OLink *rhead, *chead; //行和列链表头指针
        int mu, nu, tu;  //矩阵的行数,列数和非零元的个数
    }CrossList;
    CrossList CreateMatrix_OL(CrossList M);
    void display(CrossList M);
    int main()
    {
        CrossList M;
        M.rhead = NULL;
        M.chead = NULL;
        M = CreateMatrix_OL(M);
        printf("输出矩阵M:\n");
        display(M);
        return 0;
    }
    CrossList CreateMatrix_OL(CrossList M)
    {
        int m, n, t;
        int i, j, e;
        OLNode *p, *q;
        printf("输入矩阵的行数、列数和非0元素个数:");
        scanf("%d%d%d", &m, &n, &t);
        M.mu = m;
        M.nu = n;
        M.tu = t;
        if (!(M.rhead = (OLink*)malloc((m + 1) * sizeof(OLink))) || !(M.chead = (OLink*)malloc((n + 1) * sizeof(OLink))))
        {
            printf("初始化矩阵失败");
            exit(0);
        }
        for (i = 1; i <= m; i++)
        {
            M.rhead[i] = NULL;
        }
        for (j = 1; j <= n; j++)
        {
            M.chead[j] = NULL;
        }
        for (scanf("%d%d%d", &i, &j, &e); 0 != i; scanf("%d%d%d", &i, &j, &e)) {
            if (!(p = (OLNode*)malloc(sizeof(OLNode))))
            {
                printf("初始化三元组失败");
                exit(0);
            }
            p->i = i;
            p->j = j;
            p->e = e;
            //链接到行的指定位置
            if (NULL == M.rhead[i] || 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 (NULL == M.chead[j] || 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;
            }
        }
        return M;
    }
    void display(CrossList M) {
        for (int i = 1; i <= M.nu; i++)
        {
            if (NULL != M.chead[i])
            {
                OLink p = M.chead[i];
                while (NULL != p)
                {
                    printf("%d\t%d\t%d\n", p->i, p->j, p->e);
                    p = p->down;
                }
            }
        }
    }
    

    运行结果:

    输入矩阵的行数、列数和非0元素个数:3 3 3
    2 2 3
    2 3 4
    3 2 5
    0 0 0
    输出矩阵M:
    2 2 3
    3 2 5
    2 3 4

    展开全文
  • 资源有限,请谅解。原创作品,不喜勿喷。若有类似资源,请君主动共享。
  • 数据结构 - 十字链表稀疏矩阵存储

    千次阅读 多人点赞 2019-02-19 14:51:33
    为了减少空间的浪费,在存储稀疏矩阵的时候,我们对它进行压缩存储,即指存储非零信息。 一、数组的顺序存储 在存储稀疏矩阵的时候,除了存储非零元素的值,还需要存储其行列号i和j,故每个非零元素要用一个三元组...

    当数组中非零元素非常少时,我们可以称之为稀疏矩阵。为了减少空间的浪费,在存储稀疏矩阵的时候,我们对它进行压缩存储,即指存储非零信息。

    一、数组的顺序存储

    在存储稀疏矩阵的时候,除了存储非零元素的值,还需要存储其行列号i和j,故每个非零元素要用一个三元组(i, j, v)来描述。因为要与矩阵的对应关系,我们还需要在三元组表中增设非零元素的个数和矩阵行列大小。

    那么,稀疏矩阵的数组表达如下所示。

    struct CrossNode{ //三元组结构
        int i, j; //行列号
        ElementType value; //元素值
        CrossNode(int idx, int jdx, ElementType val):
            i(idx), j(jdx), value(val){}
    };
    
    class CrossList{ //三元组表结构
        int row, col, count; //行列数、非零元素个数
        CrossNode data[maxnum];
    }
    

    二、十字链表

    当三元组按行列序组成一个线性表,如果数组的非零元素个数较大,元素定位的效率就会比较低下。为此,我们可以采用行列两个方向交叉的十字链表,来表示稀疏矩阵。

    在这里插入图片描述

    每个非零节点不仅要存放(i, j, e),还要存放它横向的下一个结点的地址以及纵向的下一个结点的地址,形成一个类似十字形的链表的结构,具体定义如下:

    //节点结构
    struct CrossNode{
    	int i, j, value;
    	CrossNode *right, *down;
    	CrossNode(int idx, int jdx, int val) : i(idx), j(jdx), value(val), right(NULL), down(NULL){}
    };
    
    typedef struct CrossNode CLNode, *CrossLine;
    
    //十字链表
    class CrossList{
    public:
    	CrossList(){}
    	CrossList(vector< vector<int> > &arr);
    	//...
    private:
       //...
    	int row, col, count;
    	CrossLine *rowHead, *colHead;
    };
    

    这里需要注意的是,十字链表结构里的rowHead和colHead的类型是CorssLine *,也就是CrossNode * * 。

    如果把它们设置为CrossNode *类型,那么后期元素的定位和访问需要行和列的遍历,效率不高。

    完整程序

    #include <iostream>
    #include <vector>
    using namespace std;
    
    //Node Denifition
    struct CrossNode{
    	int i, j, value;
    	CrossNode *right, *down;
    	CrossNode(int idx, int jdx, int val) : i(idx), j(jdx), value(val), right(NULL), down(NULL){}
    };
    
    typedef struct CrossNode CLNode, *CrossLine;
    
    
    //Orthogonal List Definition
    class CrossList{
    public:
    	CrossList(){}
    	CrossList(vector< vector<int> > &arr);
    	void Insert(CLNode* &node);
    	void print();
    	int getCount();
    private:
    	void InsertIntoRow(CLNode* &node);
    	void InsertIntoColumn(CLNode* &node);
    	void CreateSparseMatrix(vector< vector<int> > &arr);
    
    	int row, col, count;
    	CrossLine *rowHead, *colHead;
    };
    
    //Constructor
    CrossList::CrossList(vector< vector<int> > &arr){
    	if(arr.empty()) return;
    	row = arr.size();
    	col = arr[0].size();
    	rowHead = new CrossLine[row];
    	for(int m = 0; m < row; ++m)
    		rowHead[m] = NULL;
    	colHead = new CrossLine[col];
    	for(int n = 0; n < col; ++n)
    		colHead[n] = NULL;
    	CreateSparseMatrix(arr);
    }
    
    //Insertion
    void CrossList::Insert(CLNode* &node){
    	InsertIntoRow(node);
    	InsertIntoColumn(node);
    }
    
    //Update rowHead when insertion
    void CrossList::InsertIntoRow(CLNode* &node){
    	int m = node->i;
    	if(!rowHead[m]){
    		rowHead[m] = node;
    	}
    	
    	else{
    		if(rowHead[m]->j > node->j){
    			node->right = rowHead[m];
    			rowHead[m] = node;
    		}
    		else{
    			CLNode* cur = rowHead[m]; 
    			while(cur->right && cur->right->j < node->j){
    				cur = cur->right;
    			}
    			if(!cur->right){
    				cur->right = node;
    			}
    			else{
    				node->right = cur->right;
    				cur->right = node;
    			}
    		}
    	}
    }
    
    //Update colHead when insertion
    void CrossList::InsertIntoColumn(CLNode* &node){
    	int n = node->j;
    	if(!colHead[n]){
    		colHead[n] = node;
    	}
    	else{
    		if(colHead[n]->i < node->i){
    			node->down = colHead[n];
    			colHead[n] = node;
    		}
    		else{
    			CrossLine cur = colHead[n]; //CLNode *
    			while(cur->down && cur->down->i < node->i){
    				cur = cur->down;
    			}
    			if(!cur->down){
    				cur->down = node;
    			}
    			else{
    				node->down = cur->down;
    				cur->down = node;
    			}
    		}
    	}
    }
    
    //Store sparse matrix
    void CrossList::CreateSparseMatrix(vector< vector<int> > &arr){
    	for(int m = 0; m < row; ++m){
    		for(int n = 0; n < col; ++n){
    			if(arr[m][n] != 0){
    				CLNode *newNode = new CLNode(m, n, arr[m][n]);
    				Insert(newNode);
    				++count;
    			}
    		}
    	}
    }
    
    //Print sparse matrix
    void CrossList::print(){
    	for(int m = 0; m < row; ++m){
    		CrossLine cur = rowHead[m];
    		int n = 0;
    		while(n < col){
    			if(cur && n == cur->j){
    				cout << cur->value << " ";
    				cur = cur->right;
    			}
    			else cout << "0 ";
    			++n;
    		}
    		cout << endl;
    	}
    }
    
    int CrossList::getCount(){ 
    	return count; 
    }
    
    //Test case
    int main(){
    	vector< vector<int> > arr = {
    		{0,  18, 0,  0,  0,  0},
    		{0,  0,  67, 0,  0,  0},
    		{0,  0,  0,  0,  0,  41},
    		{0,  0,  47, 62, 0,  0},
    		{0,  0,  0,  0,  0,  35}
    	};
    	CrossList testList(arr);
    	testList.print();
    }
    
    展开全文
  • 对于压缩存储稀疏矩阵,无论是使用三元组顺序,还是使用行逻辑链接的顺序,归根结底是使用数组存储稀疏矩阵。介于数组 "不利于插入和删除数据" 的特点,以上两种压缩存储方式都不适合解决类似 "...

    对于压缩存储稀疏矩阵,无论是使用三元组顺序表,还是使用行逻辑链接的顺序表,归根结底是使用数组存储稀疏矩阵。介于数组 "不利于插入和删除数据" 的特点,以上两种压缩存储方式都不适合解决类似 "向矩阵中添加或删除非 0 元素" 的问题。

    例如,A 和 B 分别为两个矩阵,在实现 "将矩阵 B 加到矩阵 A 上" 的操作时,矩阵 A 中的元素会发生很大的变化,之前的非 0 元素可能变为 0,而 0 元素也可能变为非 0 元素。对于此操作的实现,之前所学的压缩存储方法就显得力不从心。

    本节将学习用十字链表存储稀疏矩阵,该存储方式采用的是 "链表+数组" 结构,如 1 所示。

                                                                       图 1 十字链表示意图


    可以看到,使

    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼以下简单实现了数据结构中的十字链表(Java实现):代码为添加(add)方法及求和(sum)方法,其它方法后续有时间再添加,最下面有测试方法CrossList交叉链表实现代码如下:...
  • 用C++编写的稀疏矩阵乘法运算,稀疏矩阵采用十字链表存储及计算
  • 十字链表实现稀疏矩阵的加法、减法、乘法、转置、求最值、插入、查看、删除等基本功能,菜单栏采用hash表存储稀疏矩阵,给每个矩阵存储一个名字,hash函数进行寻找。
  • 十字链表的实现当稀疏矩阵的非零元数量和位置在操作过程中变化较大时(如矩阵相加),便不再适宜采用顺序存储,此时使用链式存储更为恰当。十字链表的实现typedef struct{int i,j;ElemType e;OLNode *right,*down;//...
  • 十字链表48稀疏矩阵的压缩存储数据结构Java语言描述1) 尽可能少存或不存零值元素; 解决问题的原则: 2) 尽可能减少没有实际意义的运算; 3) 操作方便。 即:能尽可能快地找到与下标值(i,j) 对应的元素,能尽可能快...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼我利用三元组进行了输出,却没有输出零元。求大侠帮忙!...// 稀疏矩阵十字链表存储表示typedef struct OLNode{int i,j; // 该非零元的行和列下标int ...
  • 本课程设计主要实现在十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行相加,操作,最后输出运算后的结果。稀疏矩阵采用十字链表表示,并在不同的存储结构下,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并...
  • #include <iostream> #include <iomanip> using namespace std; typedef int ElemType;...//该十字链表结点的右指针与下指针 }OLNode,*OLink;//十字链表结点 typedef struct { OLin.
  • 稀疏矩阵我们打算采用十字链表法进行存储。 代码实现及结果测试: ... 稀疏矩阵十字链表法实现方式 */ //十字链表的元素结点 typedef struct OLNode{ int i,j,value; //i行标 j列标 value元素值 struc...
  • 稀疏矩阵十字链表表示: 十字链表中结点的结构: 创建稀疏矩阵十字链表表示: 稀疏矩阵十字链表的查找: 稀疏矩阵十字链表表示: 每一行的非零元素构成一个带表头的环形链表 每一列的非零元素构成一个...
  • 十字链表实现稀疏矩阵的加法
  • 十字链表存储稀疏矩阵,可以起到节省空间的作用。 十字链表作为多重链表的一种,其结点分为两种: 类型1:数据域为另一个单链表的头指针。 类型2:数据域为待存储的数据。 其中,“十字”体现在:每一个存储...
  • 基于十字链表的稀疏矩阵转置
  • 稀疏矩阵存储1.三元组顺序三元组表示法就是在存储非零元的同时,存储该元素所对应的行下标和列下标。稀疏矩阵中的每一个非零元素由一个三元组(i,j,aij)唯一确定。矩阵中所有非零元素存放在由三元组组成的顺序...
  • 十字链表储存稀疏矩阵及矩阵相乘

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

    千次阅读 2013-07-10 19:44:47
    //稀疏矩阵乘法 用十字链表存储 C=A*B 输出C; Z1240 还出现超时 #include #include typedef struct mnode {  int row,col,v;  struct mnode *down,*right; }MNode; typedef struct {  int mu,nu,...
  • 十字链表存储和表示稀疏矩阵,并实现如下功能 2.基本要求 初始化:创建十字链表并从文件中读取稀疏矩阵数据(文件数据可以是三元组结构); 在十字链表上设置坐标为(i,j)的位置值为value; 获取坐标为(i...
  • 第一个term是说该矩阵有4行5列 7个非零元素 为入口 转载于:https://blog.51cto.com/13930723/2362035

空空如也

空空如也

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

十字链表存储稀疏矩阵

友情链接: KPWM.rar