稀疏矩阵的十字链表实现（C语言实现）

最新推荐文章于 2023-10-29 16:08:29 发布
最新推荐文章于 2023-10-29 16:08:29 发布
阅读量3.2k 收藏 58
点赞数 5
分类专栏： 数据结构 c语言 文章标签： 数据结构 c语言 十字链表 广义表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rainxbow/article/details/43562205
版权

又要从头学数据结构了。

默默挨个实现一遍

实现的功能包括两个矩阵的加减 相乘 还有转置 

有点繁琐 

凑合看吧

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;// 稀疏矩阵的十字链表存储表示 

typedef struct OLNode
{
	int i,j;	//该非零元的列和下标 
	ElemType e;		//非零元素值 
	struct OLNode *right,*down;		//该非零元所在行表和列表的后继链域 
}OLNode,*OLink;

typedef struct
{
	OLink *rhead,*chead;
	int mu,nu,tu;		//稀疏矩阵的行数、列数和非零元个数 
}CrossList;

//初始化M  
int InitSMatrix(CrossList *M)
{
	(*M).rhead=(*M).chead=NULL;
	(*M).mu=(*M).nu=(*M).tu=0;
	return 1;
}
//销毁稀疏矩阵M
int DestroySMatrix(CrossList *M)
{
	int i;
	OLNode *p,*q;
	
	for(i=1;i<=(*M).mu;i++)//按行释放节点 
	{
		p=*((*M).rhead+i);
		while(p)
		{
			q=p;
			p=p->right;
			free(q);
		}
	}
	free((*M).rhead);
	free((*M).chead);
	(*M).rhead=(*M).chead=NULL;
	(*M).mu=(*M).nu=(*M).tu=0;
	return 1;
} 

// 创建稀疏矩阵M，采用十字链表储存表示
int CreateSMatrix(CrossList *M)
{
	int i,j,k,m,n,t;
	ElemType e;
	OLNode *p,*q;
	if((*M).rhead)
		DestroySMatrix(M);
	printf("请输入稀疏矩阵的行数 列数 非零元素个数：（space）");
	scanf("%d %d %d",&m,&n,&t);
	(*M).mu=m;
	(*M).nu=n;
	(*M).tu=t;
	//初始化行链表头
	(*M).rhead=(OLink*)malloc((m+1)*sizeof(OLink));
	if(!(*M).rhead)
		exit(0);
	//初始化列链表头
	(*M).chead= (OLink*)malloc((n+1)*sizeof(OLink));
	if(!(*M).chead)
		exit(0);
	for(k=1;k<=m;k++)//初始化行头指针向量 各行链表为空链表 
		(*M).rhead[k]=NULL;
	for(k=1;k<=n;k++)// 初始化列头指针向量;各列链表为空链表 
		(*M).chead[k]=NULL;
	printf("请按任意次序输入%d个非零元的行 列 元素值:（空格）\n",(*M).tu);
	for(k=0;k<t;k++)
     {
         scanf("%d %d %d",&i,&j,&e);
        p=(OLNode*)malloc(sizeof(OLNode));
        if(!p)
            exit(0);
       p->i=i; // 生成结点 
       p->j=j;
       p->e=e;
       if((*M).rhead[i]==NULL||(*M).rhead[i]->j>j)    
       {
           // p插在该行的第一个结点处
           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插在该列的第一个结点处
           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 1;
} 

// 按行或按列输出稀疏矩阵M
int PrintSMatrix(CrossList M)
{
    int i,j;
    OLink p;
    printf("%d行%d列%d个非零元素\n",M.mu,M.nu,M.tu);
    printf("请输入选择(1.按行输出 2.按列输出): ");
    scanf("%d",&i);
    switch(i)
    {
    case 1: 
        for(j=1;j<=M.mu;j++)
        {
            p=M.rhead[j];
            while(p)
            {
                printf("%d行%d列值为%d\n",p->i,p->j,p->e);
                p=p->right;
            }
        }
        break;
    case 2: 
        for(j=1;j<=M.nu;j++)
        {
            p=M.chead[j];
            while(p)
            {
                printf("%d行%d列值为%d\n",p->i,p->j,p->e);
                p=p->down;
            }
        }
    }
    return 1;
}

// 由稀疏矩阵M复制得到T
int CopySMatrix(CrossList M,CrossList *T)
{
    int i;
    OLink p,q,q1,q2;
    
    if((*T).rhead)
        DestroySMatrix(T);
    (*T).mu=M.mu;
    (*T).nu=M.nu;
    (*T).tu=M.tu;
    (*T).rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink));
    if(!(*T).rhead)
        exit(0);
    (*T).chead=(OLink*)malloc((M.nu+1)*sizeof(OLink));
    if(!(*T).chead)
        exit(0);
    for(i=1;i<=M.mu;i++) // 初始化矩阵T的行头指针向量;各行链表为空链表 
        (*T).rhead[i]=NULL;
    for(i=1;i<=M.nu;i++) // 初始化矩阵T的列头指针向量;各列链表为空链表 
        (*T).chead[i]=NULL;
    for(i=1;i<=M.mu;i++) // 按行复制 
    {
        p=M.rhead[i];
        while(p) // 没到行尾 
        {
            q=(OLNode*)malloc(sizeof(OLNode)); // 生成结点 
            if(!q)
                exit(0);
            q->i=p->i; // 给结点赋值 
            q->j=p->j;
            q->e=p->e;
            if(!(*T).rhead[i]) // 插在行表头 
                (*T).rhead[i]=q1=q;
            else // 插在行表尾 
                q1=q1->right=q;
            if(!(*T).chead[q->j]) // 插在列表头 
            {
                (*T).chead[q->j]=q;
                q->down=NULL;
            }
            else // 插在列表尾 
            {
                q2=(*T).chead[q->j];
                while(q2->down)
                    q2=q2->down;
                q2->down=q;
                q->down=NULL;
            }
            p=p->right;
        }
        q->right=NULL;
    }
    return 1;
}
 // 求稀疏矩阵的和Q=M+N
int AddSMatrix(CrossList M,CrossList N,CrossList *Q)
{
    int i,k;
    OLink p,pq,pm,pn;
    OLink *col;
    
    if(M.mu!=N.mu||M.nu!=N.nu)
    {
        printf("两个矩阵不是同类型的,不能相加\n");
        exit(0);
    }
    (*Q).mu=M.mu; // 初始化Q矩阵 
    (*Q).nu=M.nu;
    (*Q).tu=0; // 元素个数的初值 
    (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
    if(!(*Q).rhead)
        exit(0);
    (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
    if(!(*Q).chead)
        exit(0);
    for(k=1;k<=(*Q).mu;k++) // 初始化Q的行头指针向量;各行链表为空链表 
        (*Q).rhead[k]=NULL;
    for(k=1;k<=(*Q).nu;k++) // 初始化Q的列头指针向量;各列链表为空链表 
        (*Q).chead[k]=NULL;
    // 生成指向列的最后结点的数组 
    col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink)); 
    if(!col)
        exit(0);
    for(k=1;k<=(*Q).nu;k++) // 赋初值 
        col[k]=NULL;
    for(i=1;i<=M.mu;i++) // 按行的顺序相加 
    {
        pm=M.rhead[i];    // pm指向矩阵M的第i行的第1个结点 
        pn=N.rhead[i];    // pn指向矩阵N的第i行的第1个结点 
        while(pm&&pn)    // pm和pn均不空 
        {
            if(pm->j<pn->j) // 矩阵M当前结点的列小于矩阵N当前结点的列 
            {
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++;    // 非零元素数加1 
                p->i=i;        // 给结点赋值 
                p->j=pm->j;
                p->e=pm->e;
                p->right=NULL;
                pm=pm->right; // pm指针向右移 
            }
            else if(pm->j>pn->j)// 矩阵M当前结点的列大于矩阵N当前结点的列 
            {
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++;    // 非零元素数加1 
                p->i=i;        // 给结点赋值 
                p->j=pn->j;
                p->e=pn->e;
                p->right=NULL;
                pn=pn->right; // pn指针向右移 
            }
            // 矩阵M、N当前结点的列相等且两元素之和不为0
            else if(pm->e+pn->e) 
            {
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++; // 非零元素数加1 
                p->i=i; // 给结点赋值 
                p->j=pn->j;
                p->e=pm->e+pn->e;
                p->right=NULL;
                pm=pm->right; // pm指针向右移 
                pn=pn->right; // pn指针向右移 
            }
            else // 矩阵M、N当前结点的列相等且两元素之和为0 
            {
                pm=pm->right; // pm指针向右移 
                pn=pn->right; // pn指针向右移 
                continue;
            }
            if((*Q).rhead[i]==NULL) // p为该行的第1个结点
                // p插在该行的表头且pq指向p(该行的最后一个结点) 
                (*Q).rhead[i]=pq=p; 
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
                 // p插在该列的表头且col[p->j]指向p  
                (*Q).chead[p->j]=col[p->j]=p;
            else // 插在col[p->]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                 // col[p->j]指向该列的最后一个结点 
                col[p->j]=col[p->j]->down;
            }
        }
        while(pm) // 将矩阵M该行的剩余元素插入矩阵Q 
        {
            p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
            if(!p)
                exit(0);
            (*Q).tu++; // 非零元素数加1 
            p->i=i; // 给结点赋值 
            p->j=pm->j;
            p->e=pm->e;
            p->right=NULL;
            pm=pm->right; // pm指针向右移 
            if((*Q).rhead[i] == NULL) // p为该行的第1个结点 
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i] = pq = p;  
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j] == NULL) // p为该列的第1个结点
                 // p插在该列的表头且col[p->j]指向p 
                (*Q).chead[p->j] = col[p->j] = p; 
            else // 插在col[p->j]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                // col[p->j]指向该列的最后一个结点 
                col[p->j]=col[p->j]->down;  
            }
        }
        while(pn) // 将矩阵N该行的剩余元素插入矩阵Q 
        {
            p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
            if(!p)
                exit(0);
            (*Q).tu++; // 非零元素数加1 
            p->i=i; // 给结点赋值 
            p->j=pn->j;
            p->e=pn->e;
            p->right=NULL;
            pn=pn->right; // pm指针向右移 
            if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i]=pq=p;  
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
                // p插在该列的表头且col[p->j]指向p  
                (*Q).chead[p->j]=col[p->j]=p; 
            else // 插在col[p->j]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                // col[p->j]指向该列的最后一个结点 
                col[p->j]=col[p->j]->down;  
            }
        }
    }
    for(k=1;k<=(*Q).nu;k++)
        if(col[k]) // k列有结点 
            col[k]->down=NULL; //  令该列最后一个结点的down指针为空 
    free(col);
    return 1;
}

//  求稀疏矩阵的差Q=M-N 
int SubtSMatrix(CrossList M,CrossList N,CrossList *Q)
{
    int i,k;
    OLink p,pq,pm,pn;
    OLink *col;
    
    if(M.mu!=N.mu||M.nu!=N.nu)
    {
        printf("两个矩阵不是同类型的,不能相加\n");
        exit(0);
    }
    (*Q).mu=M.mu; // 初始化Q矩阵 
    (*Q).nu=M.nu;
    (*Q).tu=0; // 元素个数的初值 
    (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
    if(!(*Q).rhead)
        exit(0);
    (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
    if(!(*Q).chead)
        exit(0);
    for(k=1;k<=(*Q).mu;k++) // 初始化Q的行头指针向量;各行链表为空链表 
        (*Q).rhead[k]=NULL;
    for(k=1;k<=(*Q).nu;k++) // 初始化Q的列头指针向量;各列链表为空链表 
        (*Q).chead[k]=NULL;
    // 生成指向列的最后结点的数组
    col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink)); 
    if(!col)
        exit(0);
    for(k=1;k<=(*Q).nu;k++) // 赋初值 
        col[k]=NULL;
    for(i=1;i<=M.mu;i++) // 按行的顺序相加 
    {
        pm=M.rhead[i]; // pm指向矩阵M的第i行的第1个结点 
        pn=N.rhead[i]; // pn指向矩阵N的第i行的第1个结点 
        while(pm&&pn) // pm和pn均不空 
        {
            if(pm->j<pn->j) // 矩阵M当前结点的列小于矩阵N当前结点的列 
            {
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++; // 非零元素数加1 
                p->i=i; // 给结点赋值 
                p->j=pm->j;
                p->e=pm->e;
                p->right=NULL;
                pm=pm->right; // pm指针向右移 
            }
            // 矩阵M当前结点的列大于矩阵N当前结点的列 
            else if(pm->j>pn->j) 
            {
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++; // 非零元素数加1 
                p->i=i; // 给结点赋值 
                p->j=pn->j;
                p->e=-pn->e;
                p->right=NULL;
                pn=pn->right; // pn指针向右移 
            }
            else if(pm->e-pn->e) 
            {
                // 矩阵M、N当前结点的列相等且两元素之差不为0 
                p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
                if(!p)
                    exit(0);
                (*Q).tu++; // 非零元素数加1 
                p->i=i; // 给结点赋值 
                p->j=pn->j;
                p->e=pm->e-pn->e;
                p->right=NULL;
                pm=pm->right; // pm指针向右移 
                pn=pn->right; // pn指针向右移 
            }
            else // 矩阵M、N当前结点的列相等且两元素之差为0 
            {
                pm=pm->right; // pm指针向右移 
                pn=pn->right; // pn指针向右移 
                continue;
            }
            if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i]=pq=p;  
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j]==NULL) // p为该列的第1个结点 
                // p插在该列的表头且col[p->j]指向p
                (*Q).chead[p->j]=col[p->j]=p;  
            else // 插在col[p->]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                // col[p->j]指向该列的最后一个结点 
                col[p->j]=col[p->j]->down;  
            }
        }
        while(pm) // 将矩阵M该行的剩余元素插入矩阵Q 
        {
            p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
            if(!p)
                exit(0);
            (*Q).tu++; // 非零元素数加1 
            p->i=i; // 给结点赋值 
            p->j=pm->j;
            p->e=pm->e;
            p->right=NULL;
            pm=pm->right; // pm指针向右移 
            if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i]=pq=p;  
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
                // p插在该列的表头且col[p->j]指向p  
                (*Q).chead[p->j]=col[p->j]=p; 
            else // 插在col[p->j]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                // col[p->j]指向该列的最后一个结点 
                col[p->j]=col[p->j]->down;  
            }
        }
        while(pn) // 将矩阵N该行的剩余元素插入矩阵Q 
        {
            p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
            if(!p)
                exit(0);
            (*Q).tu++; // 非零元素数加1 
            p->i=i; // 给结点赋值 
            p->j=pn->j;
            p->e=-pn->e;
            p->right=NULL;
            pn=pn->right; // pm指针向右移 
            if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i]=pq=p;  
            else // 插在pq所指结点之后 
            {
                pq->right=p; // 完成行插入 
                pq=pq->right; // pq指向该行的最后一个结点 
            }
            if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
                // p插在该列的表头且col[p->j]指向p 
                (*Q).chead[p->j]=col[p->j]=p;  
            else // 插在col[p->j]所指结点之后 
            {
                col[p->j]->down=p; // 完成列插入
                // col[p->j]指向该列的最后一个结点  
                col[p->j]=col[p->j]->down; 
            }
        }
    }
       for(k=1;k<=(*Q).nu;k++)
           if(col[k]) // k列有结点 
               col[k]->down=NULL; // 令该列最后一个结点的down指针为空 
       free(col);
       return 1;
}
// 求稀疏矩阵乘积Q=M*N 
int MultSMatrix(CrossList M,CrossList N,CrossList *Q)
{
    int i,j,e;
    OLink q,p0,q0,q1,q2;
    
    InitSMatrix(Q);
    (*Q).mu=M.mu;
    (*Q).nu=N.nu;
    (*Q).tu=0;
    (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
    if(!(*Q).rhead)
        exit(0);
    (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
    if(!(*Q).chead)
        exit(0);
    for(i=1;i<=(*Q).mu;i++) // 初始化矩阵Q的行头指针向量;各行链表为空链表 
        (*Q).rhead[i]=NULL;
    for(i=1;i<=(*Q).nu;i++) // 初始化矩阵Q的列头指针向量;各列链表为空链表 
        (*Q).chead[i]=NULL;
    for(i=1;i<=(*Q).mu;i++)
        for(j=1;j<=(*Q).nu;j++)
        {
            p0=M.rhead[i];
            q0=N.chead[j];
            e=0;
            while(p0&&q0)
            {
                if(q0->i<p0->j)
                    q0=q0->down; // 列指针后移 
                else if(q0->i>p0->j)
                    p0=p0->right; // 行指针后移 
                else // q0->i==p0->j 
                {
                    e+=p0->e*q0->e; // 乘积累加 
                    q0=q0->down; // 行列指针均后移 
                    p0=p0->right;
                }
            }
            if(e) // 值不为0 
            {
                (*Q).tu++; // 非零元素数加1 
                q=(OLink)malloc(sizeof(OLNode)); // 生成结点 
                if(!q) // 生成结点失败 
                    exit(0);
                q->i=i; // 给结点赋值 
                q->j=j;
                q->e=e;
                q->right=NULL;
                q->down=NULL;
                if(!(*Q).rhead[i]) // 行表空时插在行表头 
                    (*Q).rhead[i]=q1=q;
                else // 否则插在行表尾 
                    q1=q1->right=q;
                if(!(*Q).chead[j]) // 列表空时插在列表头 
                    (*Q).chead[j]=q;
                else // 否则插在列表尾 
                {
                    q2=(*Q).chead[j]; // q2指向j行第1个结点 
                    while(q2->down)
                        q2=q2->down; // q2指向j行最后1个结点 
                    q2->down=q;
                }
            }
        }
        return 1;
}
//  求稀疏矩阵M的转置矩阵T 
int TransposeSMatrix(CrossList M,CrossList *T)
{
    int u,i;
    OLink *head,p,q,r;
    
    if((*T).rhead)
        DestroySMatrix(T);
    CopySMatrix(M,T); // T=M 
    u=(*T).mu; // 交换(*T).mu和(*T).nu 
    (*T).mu=(*T).nu;
    (*T).nu=u;
    head=(*T).rhead; // 交换(*T).rhead和(*T).chead 
    (*T).rhead=(*T).chead;
    (*T).chead=head;
    for(u=1;u<=(*T).mu;u++) // 对T的每一行 
    {
        p=(*T).rhead[u]; // p为行表头 
        while(p) // 没到表尾,对T的每一结点 
        {
            q=p->down; // q指向下一个结点 
            i=p->i; // 交换.i和.j 
            p->i=p->j;
            p->j=i;
            r=p->down; // 交换.down.和right 
            p->down=p->right;
            p->right=r;
            p=q; // p指向下一个结点 
    }
}
return 1;
}


int main()
{
	CrossList A,B,C;
	InitSMatrix(&A);//CrossList类型使用之前必须初始化 
	InitSMatrix(&B);
	printf("创建矩阵A：\n");
	CreateSMatrix(&A); 
	PrintSMatrix(A);
	printf("由矩阵A复制矩阵B: ");
    CopySMatrix(A,&B);
    PrintSMatrix(B);
	DestroySMatrix(&B); // CrossList类型的变量在再次使用之前必须先销毁 
    printf("销毁矩阵B后:\n");
    PrintSMatrix(B);
    printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n",
    A.mu,A.nu);
    CreateSMatrix(&B);
    PrintSMatrix(B);
}



Mr_rainxbow
关注
专栏目录
matrix-c.zip_稀疏矩阵 十字链表
09-24
在C语言中实现十字链表稀疏矩阵，我们需要定义以下结构体： 1. `Node` 结构体：表示链表节点，包含元素值、行索引、列索引和指向相邻节点的指针。 2. `SparseMatrix` 结构体：表示整个稀疏矩阵，包括非零元素的数量...
稀疏矩阵加法，用十字链表实现C=A+B
zhao2018的博客
04-18 1677
Description 输入两个稀疏矩阵，输出它们相加的结果。 Input 第一行输入四个正整数，分别是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2。 接下来的t1+t2行是三元组，分别是第一个矩阵的数据和第二个矩阵的数据。三元组的第一个元素表示行号，第二个元素表示列号，第三个元素是该项的值。 Output 输出相加后的矩阵三
稀疏矩阵的加法(用十字链表实现A=A+B)
weixin_34144848的博客
08-13 1357
描写叙述： 输入两个稀疏矩阵A和B，用十字链表实现A=A+B，输出它们相加的结果。 输入： 第一行输入四个正整数，各自是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2，接下来的t1+t2行是三元组，各自是第一个矩阵的数据和第二个矩阵的数据, 三元组的第一个元素表示行,第二个元素表示列,第三个元素是该元素的值。 输出： 输出相加...
以十字链表为存储结构实现矩阵相加（严5.27）
zhao2018的博客
04-18 972
Description 以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。 Input 第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。 Output
基于十字链表的稀疏矩阵加法
m0_47616623的博客
04-28 2295
稀疏矩阵加法（十字链表）问题描述输入输出输入输出样例代码 问题描述 若将稀疏矩阵 \mathbf{A}A 的非零元素以行序为主序的顺序存于一维数组 VV 中，并用二维数组 BB 表示 AA 中的相应元素是否为零元素（以0和1分别表示零元素和非零元素）。例如， 可以使用一个数组和一个01矩阵表示 试写一算法，实现在上述表示法中实现矩阵相加的运算。并分析你的算法时间复杂度（在代码注释中给出）。 文章目录问题描述输入输出输入输出样例代码 输入 输出 输入输出样例 输入： 2 2 1 1 1 0 0 1
十字链表实现稀疏矩阵 （自己设计，可用）
10-26
十字链表是实现稀疏矩阵的一种常见方法，它通过链接非零元素来减少存储需求。本项目采用十字链表，并结合uthash库，实现了稀疏矩阵的基本操作。 首先，我们要理解稀疏矩阵的十字链表结构。每个非零元素在链表中表示...
十字链表稀疏矩阵相加
11-11
### 十字链表稀疏矩阵相加知识点详解 #### 一、背景介绍 ...通过以上内容，我们了解到在十字链表存储结构下实现稀疏矩阵相加的基本原理和技术细节。这对于理解稀疏矩阵的存储优化以及相关的算法实现非常重要。
matrix 基于十字链表的稀疏矩阵 C语言
09-19
本文将详细介绍如何用C语言实现基于十字链表的稀疏矩阵，并探讨相关的设计技巧。 首先，我们需要理解十字链表的概念。十字链表是一种适用于存储稀疏矩阵的数据结构，它通过四个指针分别连接同一行、同一列、主对角...
十字链表实现矩阵相加
12-09
在学习《数据结构（C语言版）》中第五章稀疏矩阵时，课本提示使用十字链表实现矩阵相加，没能运行，于是自己调试实现了下，希望对大家有帮助
稀疏矩阵相加用十字链表表示（C语言）
Lucky Home
03-31 2609
最近做学校数据结构的作业题有点上头，今天这个十字链表也算啃下来了。趁热打铁，赶紧把题解发下。 题目： 主程序： #include<stdio.h> #include<stdlib.h> typedef struct OLNode//定义一个结点 { int row,col;//行，列 int e;//存储的值 struct OLNode *down,*right;//向下的指针与向右的指针向量 }Node,*LNODE; typedef struct {
西工大NOJ数据结构实验——实验2.3：稀疏矩阵加法，用十字链表实现C=A+B
a15735748145a的博客
04-06 4479
西工大NOJ数据结构实验——实验2.3：稀疏矩阵加法，用十字链表实现C=A+B
数据结构13——以十字链表为存储结构实现矩阵相加（严5.27）
chengchencheng的博客
05-30 1740
Description以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。Input第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。Output输出相加后的矩阵三元组。Sampl...
以十字链表为存储结构实现矩阵相加
cl博客
05-03 1716
以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。输出相加后的矩阵三元组。3 4 3 21 1 11 3 12 2 21 2 1...
矩阵相加（十字链表）
axiqia的专栏
03-25 4734
描述 输入两个稀疏矩阵A和B，用十字链表实现A=A+B，输出它们相加的结果。   输入 第一行输入四个正整数，分别是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2，接下来的t1+t2行是三元组，分别是第一个矩阵的数据和第二个矩阵的数据, 三元组的第一个元素表示行,第二个元素表示列,第三个元素是该元素的值。   输出 输出相加后的矩阵三元组。  
稀疏矩阵之十字链表压缩存储并且实现两个稀疏矩阵相加
Specif1c的博客
11-12 1361
稀疏矩阵的十字链式压缩存储： 代码演示： /* * Date: 2020/11/10 * Author: XiaoXiangWei * Work: Sparse matrix addition * */ #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status;
清华大学出版数据结构第五版的链表的使用方法_数据结构和算法学习指南
weixin_39575212的博客
11-18 167
点击上方蓝字设为星标下面开始今天的学习～这篇文章会涵盖之前的所有内容，并且会举很多代码的实例，谈谈如何使用框架思维，并且给对于算法无从下手的朋友给一点具体可执行的刷题建议。首先，这里讲的都是普通的数据结构和算法，咱不是搞竞赛的，野路子出生，只解决常规的问题，以面试为最终目标。另外，以下是我个人的经验的总结，没有哪本算法书会写这些东西，所以请读者试着理解我的角度，别纠结于细节问题，因为这篇...
【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）
最新发布
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-29 914
本文介绍了十字链表的矩阵操作，包括加法、乘法、转置等
数据结构稀疏矩阵的加法十字链表_数据结构笔记
weixin_34236672的博客
01-08 549
1、数据结构数据结构的基本概念数据是信息的载体数据元素是数据的基本单位，又若干数据项组成数据对象是具有相同性质的数据元素的集合，是数据的一个子集数据类型原子类型、结构类型、抽象数据类型抽象数据类型(ADT)指一个数学模型及其定义在该模型上的一组操作数据结构是相互之间存在一种或多种特定关系的数据元素的集合数据结构三要素逻辑结构线性结构(数据之间一对一的关系)2、线性表★p25定义：具有相同...
稀疏矩阵存储：十字链表实现
"该资源是数据结构课程中的第五章，主要讲解了数组和广义表的相关内容，特别是如何创建稀疏矩阵M，采用十字链表作为数据结构。" 在数据结构课程中，稀疏矩阵是一种高效存储大量零元素的矩阵方法，特别是当非零元素...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值