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

最新推荐文章于 2022-04-06 09:40:00 发布
最新推荐文章于 2022-04-06 09:40:00 发布
阅读量3.3k 收藏 59
点赞数 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` 结构体：表示整个稀疏矩阵，包括非零元素的数量...
18、数据结构笔记之十八链表实现稀疏矩阵
badman250的专栏
09-14 5625
18、数据结构笔记之十八链表实现稀疏矩阵            “必须如蜜蜂一样，采过许多花，才能酿出蜜来。”             上篇中实现了栈在多项式实现中的例子，再来看下稀疏矩阵通过链表方式实现。            关键字：十字链表存储 1.  十字链表存储            十字链表（OrthogonalList)是有向图的另一种链式存储结构。该结构可以看成是将有
稀疏矩阵的加法(用十字链表实现A=A+B)
weixin_34144848的博客
08-13 1374
描写叙述： 输入两个稀疏矩阵A和B，用十字链表实现A=A+B，输出它们相加的结果。 输入： 第一行输入四个正整数，各自是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2，接下来的t1+t2行是三元组，各自是第一个矩阵的数据和第二个矩阵的数据, 三元组的第一个元素表示行,第二个元素表示列,第三个元素是该元素的值。 输出： 输出相加...
稀疏矩阵加法，用十字链表实现C=A+B
zhao2018的博客
04-18 1717
Description 输入两个稀疏矩阵，输出它们相加的结果。 Input 第一行输入四个正整数，分别是两个矩阵的行m、列n、第一个矩阵的非零元素的个数t1和第二个矩阵的非零元素的个数t2。 接下来的t1+t2行是三元组，分别是第一个矩阵的数据和第二个矩阵的数据。三元组的第一个元素表示行号，第二个元素表示列号，第三个元素是该项的值。 Output 输出相加后的矩阵三
以十字链表为存储结构实现矩阵相加（严5.27）
zhao2018的博客
04-18 984
Description 以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。 Input 第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。 Output
十字链表实现稀疏矩阵，包含十二大功能
m0_46335449的博客
11-19 3100
## 题目： 十字链表实现稀疏矩阵 1．问题描述 用十字链表存储和表示稀疏矩阵，并实现如下功能 2．基本要求 初始化：创建十字链表并从文件中读取稀疏矩阵数据（文件数据可以是三元组结构）； 在十字链表上设置坐标为（i，j）的位置值为value； 获取坐标为（i，j）的位置的值； 插入一项、删除某项的值； 输出十字链表表示的稀疏矩阵； 实现两个稀疏矩阵的加法、减法、乘法的功能，结果保存到新的十字链表中； 实现把十字链表表示的稀疏矩阵存入文件； 可以用菜单选择所有功能，设计良好的操作界面
十字链表实现稀疏矩阵 （自己设计，可用）
最新发布
10-26
十字链表是实现稀疏矩阵的一种常见方法，它通过链接非零元素来减少存储需求。本项目采用十字链表，并结合uthash库，实现了稀疏矩阵的基本操作。 首先，我们要理解稀疏矩阵的十字链表结构。每个非零元素在链表中表示...
十字链表稀疏矩阵相加
11-11
### 十字链表稀疏矩阵相加知识点详解 #### 一、背景介绍 ...通过以上内容，我们了解到在十字链表存储结构下实现稀疏矩阵相加的基本原理和技术细节。这对于理解稀疏矩阵的存储优化以及相关的算法实现非常重要。
matrix 基于十字链表的稀疏矩阵 C语言
09-19
本文将详细介绍如何用C语言实现基于十字链表的稀疏矩阵，并探讨相关的设计技巧。 首先，我们需要理解十字链表的概念。十字链表是一种适用于存储稀疏矩阵的数据结构，它通过四个指针分别连接同一行、同一列、主对角...
十字链表实现矩阵相加
12-09
在学习《数据结构（C语言版）》中第五章稀疏矩阵时，课本提示使用十字链表实现矩阵相加，没能运行，于是自己调试实现了下，希望对大家有帮助
基于十字链表的稀疏矩阵加法
m0_47616623的博客
04-28 2352
稀疏矩阵加法（十字链表）问题描述输入输出输入输出样例代码 问题描述 若将稀疏矩阵 \mathbf{A}A 的非零元素以行序为主序的顺序存于一维数组 VV 中，并用二维数组 BB 表示 AA 中的相应元素是否为零元素（以0和1分别表示零元素和非零元素）。例如， 可以使用一个数组和一个01矩阵表示 试写一算法，实现在上述表示法中实现矩阵相加的运算。并分析你的算法时间复杂度（在代码注释中给出）。 文章目录问题描述输入输出输入输出样例代码 输入 输出 输入输出样例 输入： 2 2 1 1 1 0 0 1
稀疏矩阵相加用十字链表表示（C语言）
Lucky Home
03-31 2735
最近做学校数据结构的作业题有点上头，今天这个十字链表也算啃下来了。趁热打铁，赶紧把题解发下。 题目： 主程序： #include<stdio.h> #include<stdlib.h> typedef struct OLNode//定义一个结点 { int row,col;//行，列 int e;//存储的值 struct OLNode *down,*right;//向下的指针与向右的指针向量 }Node,*LNODE; typedef struct {
清华大学出版数据结构第五版的链表的使用方法_数据结构和算法学习指南
weixin_39575212的博客
11-18 180
点击上方蓝字设为星标下面开始今天的学习～这篇文章会涵盖之前的所有内容，并且会举很多代码的实例，谈谈如何使用框架思维，并且给对于算法无从下手的朋友给一点具体可执行的刷题建议。首先，这里讲的都是普通的数据结构和算法，咱不是搞竞赛的，野路子出生，只解决常规的问题，以面试为最终目标。另外，以下是我个人的经验的总结，没有哪本算法书会写这些东西，所以请读者试着理解我的角度，别纠结于细节问题，因为这篇...
西工大NOJ数据结构实验——实验2.3：稀疏矩阵加法，用十字链表实现C=A+B
a15735748145a的博客
04-06 4526
西工大NOJ数据结构实验——实验2.3：稀疏矩阵加法，用十字链表实现C=A+B
将图的广度优先遍历在邻接矩阵和邻接表存储结构上分别实现_图解：什么是“图”？
weixin_39921131的博客
11-24 453
从今天开始，我们开始介绍图的相关算法 什么是“图”1、背景 作为图的开始，我们先来看一个经典的问题，它被认为是图论的起源。 这个问题是基于一个现实生活中的事例：河中心有两个小岛。小岛与河的两岸有七条桥连接。在所有桥都只能走一遍的前提下，如何才能把这个地方所有的桥都走遍？欧拉在1735年提出，并没有方法能圆满解决这个问题，他更在第二年发表在论文《柯尼斯堡的七桥》中，证明符合条件的走法并不存在欧拉...
以十字链表为存储结构实现矩阵相加
cl博客
05-03 1730
以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。输出相加后的矩阵三元组。3 4 3 21 1 11 3 12 2 21 2 1...
11.十字链表 实现 稀疏矩阵 及 矩阵相加
我多么希望明天有太阳，来灼烧我腐烂的梦想
04-17 2552
#include #include FILE *fp; // 十字链表 实现 稀疏矩阵 及 矩阵相加 #define OK 0 #define ERROR 1 #define OVERFLOW 1 typedef bool Status; typedef char ElemType; typedef struct OLNode//节点信息 { int i, j; struct OLNo
稀疏矩阵之十字链表压缩存储并且实现两个稀疏矩阵相加
Specif1c的博客
11-12 1425
稀疏矩阵的十字链式压缩存储： 代码演示： /* * 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;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值