[数据结构] 严蔚敏 矩阵的十字链表存储方法

最新推荐文章于 2021-08-06 17:06:33 发布
最新推荐文章于 2021-08-06 17:06:33 发布
阅读量983 收藏 1
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/as12cs/article/details/81106452
版权

直接上代码。

最关键的是每次创建新结点之后插入十字链表的算法，也就是分析新结点指针指向的位置，这部分在最后InserttoChainTable函数里。虽然各种变量命名很奇怪，但是能标注的都尽量标注全了。

#include <stdio.h>
#include <stdlib.h>
#include "CrossList.h"

int main()
{
    printf("验证十字链表矩阵的函数\n");
    CrossList M,N;
    {
        FILE *fp = fopen("TestData.txt","r");
//        if (!fp)
//            exit (-1);
        printf("从文件中创建两个矩阵\n");
        CreateSMatrix_OL(fp,2,&M,&N);
        fclose(fp);
        printf("M = \n");
        PrintSMatrix_OL(M);
        printf("N = \n");
        PrintSMatrix_OL(N);
        printf("\n");
    }

    {
        CrossList Tmp;
        printf("将M拷贝到Tmp\n");
        CopySMatrix_OL(&Tmp,M);
        printf("Tmp = \n");
        PrintSMatrix_OL(Tmp);
        printf("\n");
    }
    {
        CrossList T;
        printf("T = M + N = \n");
        AddSMatrix_OL(&T,M,N);
        PrintSMatrix_OL(T);
        printf("\n");
        printf("T = M - N = \n");
        SubSMatrix_OL(&T,M,N);
        PrintSMatrix_OL(T);
        printf("\n");
    }
    {
        CrossList T;
        printf("T = M * N = \n");
        MultSMatrix_OL(&T,M,N);
        PrintSMatrix_OL(T);
        printf("\n");
    }
    {
        CrossList T;
        printf("T = M(T) = \n");
        TransposeSMatrix_OL(&T,M);
        PrintSMatrix_OL(T);
        printf("\n");
    }
    {
        printf("销毁M,N\n");
        DestroySMatrix_OL(&M);
        DestroySMatrix_OL(&N);
        !M.mu && !M.nu && !M.tu && !N.mu && !N.tu && !N.nu? printf("M和N不存在\n"):printf("M和N存在\n");
        printf("\n");
    }
    return 0;
}

 

/**********************************
 *                                *
 * 文件夹: ▲01 绪论              *
 *                                *
 * 文件名: Status.h               *
 *                                *
 * 内  容: 相关状态码及宏函数列表 *
 *                                *
 **********************************/ 

#ifndef STATUS_H
#define STATUS_H

/* 状态码 */
#define	TRUE		1			//真 
#define	FALSE		0			//假
#define YES			1			//是
#define NO          0			//否 
#define	OK			1			//通过
#define	ERROR		0			//错误
#define SUCCESS		1			//成功 
#define UNSUCCESS	0			//失败 
#define	INFEASIBLE	-1			//不可行

#ifndef _MATH_H_ 				//系统中已有此状态码定义，要避免冲突 
#define	OVERFLOW	-2			//堆栈上溢
#define UNDERFLOW	-3			//堆栈下溢
#endif 

#ifndef NULL
#define NULL ((void*)0)
#endif

/* 状态码识别类型 */
typedef int Status;

/*宏函数*/
//函数暂停一段时间
#define Wait(x)\
 {\
	double _Loop_Num_;\
	for(_Loop_Num_=0.01; _Loop_Num_<=100000.0*x; _Loop_Num_+=0.01)\
		;\
 }//设立一个空循环 

//摁Enter键继续 
#define PressEnter\
 {\
	fflush(stdin);\
	printf("Press Enter...");\
	getchar();\
	fflush(stdin);\
 }

#endif

#ifndef CROSSLIST_H
#define CROSSLIST_H

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include "Status.h"
#include "Scanf.h"

//十字链表类型定义
typedef int CElemType;

typedef struct OLNode
{
    int i,j;
    CElemType e;
    struct OLNode *right;
    struct OLNode *down;
} OLNode,*OLink;

typedef struct
{
    OLink *rhead; //行链表头指针
    OLink *chead; //列链表头指针
    int mu,nu,tu;
} CrossList;

//函数表
Status CreateSMatrix_OL (FILE *fp,int n,...);

void DestroySMatrix_OL (CrossList *T);

void PrintSMatrix_OL (CrossList T);

void CopySMatrix_OL (CrossList *T, CrossList M);

Status AddSMatrix_OL (CrossList *T,CrossList M, CrossList N);

Status SubSMatrix_OL (CrossList *T, CrossList M, CrossList N);

Status MultSMatrix_OL (CrossList *T, CrossList M,CrossList N);

void TransposeSMatrix_OL (CrossList *T, CrossList M);

Status InserttoChainTable (OLink p, OLink *tmp, OLink tmpcol, CrossList *T);

Status InitMatrixandChain (CrossList *T);
#endif // CROSSLIST_H

#ifndef CROSSLIST_C
#define CROSSLIST_C

#include "CrossList.h"

十字链表类型定义
//typedef int CElemType;
//typedef struct OLNode
//{
//    int i,j;
//    CElemType e;
//    struct OLNode *right;
//    struct OLNode *down;
//} OLNode,*OLink;
//typedef struct
//{
//    OLink *rhead; //行链表头指针
//    OLink *chead; //列链表头指针
//    int mu,nu,tu;
//} CrossList;

//函数表
Status CreateSMatrix_OL (FILE *fp,int n,...)
{
    if (n<1)
        return ERROR;

    int count; //用来计算输入的矩阵个数
    int k; //临时使用的变量
    int number; //扫描时临时使用的变量
    char *tmps;
    OLink p; //用来代表新加入的结点
    OLink q; //用来遍历每行的链表进而与p比较
    CrossList *M; //指向输入的矩阵
    va_list ap;
    va_start (ap,n);
    for (count=1;count<=n;count++){
        M = va_arg(ap,CrossList *);

        tmps = (char *)malloc(5*sizeof(char));
        for (k=0;k<3;k++){
            fscanf(fp,"%s %d",tmps,&number);
            if (strcmpi(tmps,"row:")==0)
                M->mu = number;
            else if (strcmpi(tmps,"col:")==0)
                M->nu = number;
            else if (strcmpi(tmps,"num:")==0)
                M->tu = number;
        }

        fscanf(fp,"%s",tmps);
        if (strcmpi(tmps,"data:")==0){
            //为chead，rhead动态申请空间,注意数组0号不放指针
           InitMatrixandChain (M);

            for (k=1;k<=M->tu;k++){
                p = (OLink) malloc (sizeof(OLNode));
                if (!p)
                    exit (OVERFLOW);

                if (k==1){
                    fscanf(fp," (%d,%d,%d)",&(p->i),&(p->j),&(p->e));
//                     printf("(%d,%d,%d)",(p->i),(p->j),(p->e));
                } else{
                    fscanf(fp,",(%d,%d,%d)",&(p->i),&(p->j),&(p->e));
//                    printf(",(%d,%d,%d)",(p->i),(p->j),(p->e));
                }
//                printf("%d%d%d",p->i,p->j,p->e);
                p->right = p->down = NULL;
                //定位插入行的哪个位置
                if (M->rhead[p->i]==NULL || M->rhead[p->i]->j>p->j){
                    //如果需要插入链表第一位则
                    p->right = M->rhead[p->i];
                    M->rhead[p->i] = p;
                } else {
                    //需要确保比较j的时候q所在结点一定是存在的,更加严谨
                    for (q = M->rhead[p->i];(q->right) && (q->right->j<p->j);q = q->right){}
                    //q指向应当插入的前一位Node;另外防止第一位重复
                    if (q->j==p->j || (q->right) && (q->right->j==p->j)){
                        printf("Repeated position.\n");
                        return ERROR;
                    }
                    p->right = q->right;
                    q->right = p;
                }
                //需要完成列插入
                if(M->chead[p->j]==NULL || M->chead[p->j]->i>p->i){
                    p->down = M->chead[p->j];
                    M->chead[p->j] = p;
                } else {
                    for (q = M->chead[p->j]; (q->down) && (q->down->i<p->i);q = q->down){}

                    if (q->i==p->i || (q->down) && (q->down->i==p->i)){
                        printf("Repeated position.\n");
                        return ERROR;
                    }
                    p->down = q->down;
                    q->down = p;
                }
            }
        }
    }
    free(tmps);
    va_end(ap);
    return OK;
}

void DestroySMatrix_OL (CrossList *T)
{
    //主要是处理行和列的链表
    OLink row,tmp;
    int i;
    for (i=1;i<=T->mu;i++){
        row = T->rhead[i];
        while (row){
            tmp = row;
            row = row->right;
            free(tmp);
        }
    }
    free(T->rhead);
    free(T->chead);

    T->rhead = T->chead = NULL;
    T->mu = T->nu = T->tu = 0;
}

void PrintSMatrix_OL (CrossList T)
{
    OLink p;
    int i,j;
    for (i=1;i<=T.mu;i++){
        p = T.rhead[i];
        for (j=1;j<=T.mu;j++){
            if (p && p->j==j){
                printf("%d\t",p->e);
                p = p->right;
            } else
                printf("0\t");
        }
        printf("\n");
    }
}

void CopySMatrix_OL (CrossList *T, CrossList M)
{
    T->mu = M.mu;
    T->nu = M.nu;
    T->tu = M.tu;
    int k,i;
    OLink p,q,tmp,tmpcol;
    InitMatrixandChain (T);

    for (i=1;i<=M.mu;i++){
        q = M.rhead[i];
        if (!q)
            continue;
        while (q){
            p = (OLink)malloc(sizeof(OLNode));
            if (!p)
                exit(OVERFLOW);
            p->i = q->i;
            p->j = q->j;
            p->e = q->e;
            p->right = p->down = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);

            q = q->right;
        }
    }
}

Status AddSMatrix_OL (CrossList *T,CrossList M, CrossList N)
{
    if(M.mu!=N.mu || M.nu!=N.nu){
        printf("Cannot add these two matrix.\n");
        return ERROR;
    }
    int k;
    T->mu = M.mu;
    T->nu = M.nu;
    T->tu = 0;
    InitMatrixandChain (T);

    int row;
    OLink pm,pn,p,tmp,tmpcol;
    for (row=1;row<=M.mu;row++){
        //从第一行遍历
        pm = M.rhead[row];
        pn = N.rhead[row];

        while (pm && pn){
            //当前行均有未扫描的单元
            //区分是否需要创建结点
            if (pm->j==pn->j && pm->e+pn->e==0){
                pm = pm->right;
                pn = pn->right;
                continue;
            }
            p = (OLink)malloc (sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            if (pm->j<pn->j){
                p->i = pm->i;
                p->j = pm->j;
                p->e = pm->e;
                pm = pm->right;
            } else if (pm->j>pn->j){
                p->i = pn->i;
                p->j = pn->j;
                p->e = pn->e;
                pn = pn->right;
            } else {
                p->i = pm->i;
                p->j = pm->j;
                p->e = pm->e + pn->e;
                pm = pm->right;
                pn = pn->right;
            }
            //创建完之后处理指针
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
        }
        while(pm){
            p = (OLNode*)malloc(sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            p->i = pm->i;
            p->j = pm->j;
            p->e = pm->e;
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
            pm = pm->right;
        }
        while(pn){
            p = (OLNode*)malloc(sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            p->i = pn->i;
            p->j = pn->j;
            p->e = pn->e;
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
            pn = pn->right;
        }
    }
    return OK;
}

Status SubSMatrix_OL (CrossList *T, CrossList M, CrossList N)
{
    if(M.mu!=N.mu || M.nu!=N.nu){
        printf("Cannot sub these two matrix.\n");
        return ERROR;
    }
    T->mu = M.mu;
    T->nu = M.nu;
    T->tu = 0;
    InitMatrixandChain (T);

    int row;
    OLink pm,pn,p,tmp,tmpcol;
    for (row=1;row<=M.mu;row++){
        //从第一行遍历
        pm = M.rhead[row];
        pn = N.rhead[row];

        while (pm && pn){
            //当前行均有未扫描的单元
            //区分是否需要创建结点
            if (pm->j==pn->j && pm->e+pn->e==0){
                pm = pm->right;
                pn = pn->right;
                continue;
            }
            p = (OLink)malloc (sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            if (pm->j<pn->j){
                p->i = pm->i;
                p->j = pm->j;
                p->e = pm->e;
                pm = pm->right;
            } else if (pm->j>pn->j){
                p->i = pn->i;
                p->j = pn->j;
                p->e = -pn->e;
                pn = pn->right;
            } else {
                p->i = pm->i;
                p->j = pm->j;
                p->e = pm->e - pn->e;
                pm = pm->right;
                pn = pn->right;
            }
            //创建完之后处理指针
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
        }
        while(pm){
            p = (OLNode*)malloc(sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            p->i = pm->i;
            p->j = pm->j;
            p->e = pm->e;
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
            pm = pm->right;
        }
        while(pn){
            p = (OLNode*)malloc(sizeof(OLNode));
            if (!p)
                exit (OVERFLOW);
            p->i = pn->i;
            p->j = pn->j;
            p->e = -pn->e;
            p->down = p->right = NULL;
            InserttoChainTable (p,&tmp,tmpcol, T);
            pn = pn->right;
        }
    }
    return OK;
}

Status MultSMatrix_OL (CrossList *T, CrossList M,CrossList N)
{
    if (M.nu!=N.mu){
        printf("Unable to Multiply.\n");
        return ERROR;
    }
    T->mu = M.mu;
    T->nu = N.nu;
    T->tu = 0;
    InitMatrixandChain(T);

    int mrow,ncol;
    CElemType e;
    OLink pm,pn,p,tmp,tmpcol;

    if (M.tu*N.tu){
        for (mrow=1;mrow<=M.mu;mrow++){
            for (ncol=1;ncol<=N.nu;ncol++){
                pm = M.rhead[mrow];
                pn = N.chead[ncol];
                e=0;

                while (pm && pn){
                    if (pm->j<pn->i)
                        pm = pm->right;
                    else if (pm->j>pn->i)
                        pn = pn->down;
                    else{
                        e+=pm->e*pn->e;
                        pm = pm->right;
                        pn = pn->down;
                    }
                }
                if (e){
                    p = (OLink)malloc(sizeof(OLNode));
                    if (!p)
                        exit(OVERFLOW);
                    p->i = M.rhead[mrow]->i;
                    p->j = N.chead[ncol]->j;
                    p->e = e;
                    p->right = p->down = NULL;
                    InserttoChainTable (p, &tmp, tmpcol, T);
                }
            }
        }
    }
    return OK;
}

void TransposeSMatrix_OL (CrossList *T, CrossList M)
{
    T->mu = M.mu;
    T->nu = M.nu;
    T->tu = M.tu;
    InitMatrixandChain(T);

    int i;
    OLink p,pm,tmp,tmpcol;
    if (T->tu){
        for (i=1;i<=M.nu;i++){
            pm = M.chead[i];
            if (!pm)
                continue;
            while (pm){
                p = (OLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(OVERFLOW);
                p->i = pm->j;
                p->j = pm->i;
                p->e = pm->e;
                p->right = p->down = NULL;
                InserttoChainTable (p, &tmp, tmpcol, T);
                pm=pm->down;
            }
        }
    }
}

Status InserttoChainTable (OLink p, OLink *tmp, OLink tmpcol, CrossList *T)
{
    T->tu++;
    if (T->rhead[p->i]==NULL)
        T->rhead[p->i] = p;
    else
        (*tmp)->right = p;
    *tmp = p;

    if (T->chead[p->j]==NULL || T->chead[p->j]->i>p->i){
        (*tmp)->down = T->chead[p->j];
        T->chead[p->j] = *tmp;
    } else {
        for (tmpcol=T->chead[p->j];(tmpcol->down)&&(tmpcol->down->i<p->i);tmpcol = tmpcol->down){}

        (*tmp)->down = tmpcol->down;
        tmpcol->down = *tmp;
    }
}

Status InitMatrixandChain (CrossList *T)
{
    T->rhead = (OLink *)malloc((T->mu+1)*sizeof(OLink));
    if (!T->rhead)
        exit (OVERFLOW);
    T->chead = (OLink *)malloc((T->nu+1)*sizeof(OLink));
    int k;
    if (!T->chead)
        exit (OVERFLOW);
    for (k=0;k<=T->mu;k++){
        T->rhead[k] = NULL;
    }
    for (k=0;k<=T->nu;k++){
        T->chead[k] = NULL;
    }
    return OK;
}
#endif // CROSSLIST_C

文档中的测试数据：

Row: 5
Col: 5
Num: 10
Data: (1,2,1),(1,4,5),(2,3,-3),(2,5,2),(3,1,2),(3,2,3),(3,3,4),(4,4,2),(5,1,3),(5,2,-1)

Row: 5
Col: 5
Num: 8
Data: (1,1,-3),(1,3,2),(2,4,-1),(3,2,4),(4,1,6),(4,5,5),(5,1,3),(5,3,2)

as12cs
关注
专栏目录
图的十字链表存储法详解
数据结构和算法教程（C语言版）
04-15 4869
前面介绍了图的邻接表存储法，本节继续讲解图的另一种链式存储结构——十字链表法。 与邻接表不同，十字链表法仅适用于存储有向图和有向网。不仅如此，十字链表法还改善了邻接表计算图中顶点入度的问题。 十字链表存储有向图（网）的方式与邻接表有一些相同，都以图（网）中各顶点为首元节点建立多条链表，同时为了便于管理，还将所有链表的首元节点存储到同一数组（或链表）中。 其中，建立个各个链表中用于存储顶点的首元节点...
《数据结构：c语言版》（严蔚敏）知识点整合
热门推荐
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
06-18 1万+
数据结构是相互之间存在一种或多种特定关系的数据元素的集合， 《数据结构》让读者认识到了各种数据结构在处理数据上的优缺点， 理解掌握相关数据结构的具体操作，在结构的基础上添加好的算法，就能够更好的处理和利用数据。 算法的时间空间复杂度： 线性表： 线性表的顺序存储结构 用一组连续的存储单元依次存储线性表的数据元素。 特点：线性表的顺序存储是一种随机存取的存储结构。 随机存取：即读写存储的消息的时间与存储的位置无关 相关操作： 2.插入： 3.查找 4.删除 1.初始化 2.单链表的插入 3.查找 4.
十字链表 数据结构 严蔚敏
weixin_43499703的博客
05-06 476
对十字链表的理解 1 2 3 4 5 tailvex headvex hlink tlink infor 弧结点的结构 hlink为指向弧头相同的下一条弧（与firstin对应） tlink为指向弧尾相同的下一条弧（与firstout对应） infor图中没有表示，所以只有四个域 1 2 3 data first...
5-4-十字链表（稀疏矩阵）-数组和广义表-第5章-《数据结构》课本源码-严蔚敏吴伟民版...
weixin_33779515的博客
02-29 117
课本源码部分 第5章  数组和广义表 - 十字链表（稀疏矩阵） ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文...
数据结构-矩阵压缩存储(十字链表、三元组顺序表、行逻辑链接的顺序表）
huanhuan59的博客
12-09 2666
1.如果矩阵中有很多数值相同的数据元素，在存储时，可以考虑对其进行适当的压缩存储。 有必要压缩存储的矩阵大致分为两大类： 矩阵中含有大量的相同数值，称为特殊矩阵（例如对称矩阵和上下三角矩阵）。 矩阵中只有极少量的元素是非 0 元素，称为稀疏矩阵。 2.两类矩阵压缩存储的方法： 特殊矩阵中，对于相同的数据元素，只存储一个。 稀疏矩阵中，只需要存储非 0 元素。 3.对称矩阵 如果n阶矩阵中...
数组的十字链表存储
12-09 430
#include #include #include typedef int ElemType; struct Node { int row;int col; Node *down; Node *right; union // 定义公用体以节省空间 { Node *next; ElemType val...
数据结构 严蔚敏 代码
03-14
范例1-104 有向图的十字链表存储表示 335 ∷相关函数：CreateDG函数 1.7.4 无向图的邻接多重表存储表示 344 范例1-105 无向图的邻接多重表存储表示 344 ∷相关函数：CreateGraph函数 1.7.5 最小生成树 355 范例1-106...
数据结构严蔚敏C语言版学习复习提纲.doc
最新发布
07-30
矩阵在数据结构中也有重要地位，稀疏矩阵采用三元组或十字链表存储，可以节省大量空间。广义表的存储通常采用链表结构，允许元素共享，支持多层次结构。 总的来说，本复习提纲覆盖了数据结构的基础理论和实际应用，...
数据结构算法实现(严蔚敏版配套实现程序)
02-26
数据结构算法实现(严蔚敏版配套实现程序) 1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数：fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 ...
C语言矩阵求逆（源代码）
05-22
C语言中这样求其逆矩阵，矩阵求逆的源代码。非常实用。
6.图——数据结构（严蔚敏 C语言版）
一个人的博客
08-06 1710
6.图 6.1定义和术语 无向图: 每条边都是无方向的 有向图: 每条边都是有方向的 完全图: 任意两个点都有一条边相连。 无向完全图：n个顶点，n（n-1)/2条边 有向完全图：n个顶点，n(n-1)条边 网: 边/弧带权的图。 邻接: 有边/弧相连的两个顶点之间的关系。 存在(v, v)，则称v,和v互为邻接点; 存在<Vi; Vj>，则称vi邻接到vj,vj邻接于vi。 顶点的度: 与该顶点相关联的边的数目，记为TD(v)；在有向图中，顶点的度等于该顶点的入度与出度之和。顶点v的入
稀疏矩阵的十字链表存储表示
RowandJJ
05-08 3998
十字链表用的不多，但是面试可能会出现，故而记录一下。 十字链表节点形态： 十字链表形态： 实现： /*************************************** 稀疏矩阵的十字链表存储表示 by Rowandjj 2014/5/7 ***************************************/ #include
(六)图的十字链表存储法详解
majiakun1的专栏
03-20 2951
与邻接表不同，十字链表法仅适用于存储有向图和有向网。不仅如此，十字链表法还改善了邻接表计算图中顶点入度的问题。 十字链表存储有向图（网）的方式与邻接表有一些相同，都以图（网）中各顶点为首元节点建立多条链表，同时为了便于管理，还将所有链表的首元节点存储到同一数组（或链表）中。 其中，建立个各个链表中用于存储顶点的首元节点结构如图 1 所示： 图 1 十字链表中首元节点结构示意图 从图 1 可...
5.3.4 矩阵及其十字链表结构
engineer0的博客
12-19 1966
产生背景 矩阵的非零元个数和位置在操作过程中变化较大，不再适合采用顺序三元组表示。因此产生了一种用链式存储结构来表示三元组的线性表。 使用十字链表来表示矩阵 1、矩阵中每个非零元可用一个含有5个域的结点来表示：i，j，e 表示该非零元所在的行数，列数，元素值；向右域 right 用以链接同一行中下一个非零元；向下域 down 用以链接同一列中下一个非零元。 2、每个非零元同时是某个行列表或者列链表的结点，把一个矩阵转化成了一个十字交叉的链表。 3、可用两个一维数组来表示，分别存储行链表的头指针和列链..
以十字链表为存储结构实现矩阵相加
cl博客
05-03 1717
以十字链表为存储结构，编写程序，将稀疏矩阵B加到稀疏矩阵A上。第一行输入四个正整数，分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示，其中第一个元素表示非零元素所在的行值，第二个元素表示非零元素所在的列值，第三个元素表示非零元素的值。输出相加后的矩阵三元组。3 4 3 21 1 11 3 12 2 21 2 1...
十字链表矩阵
tianya_team
01-04 1057
希望高手能够提供矩阵求逆思路： #include #include #include typedef int ElemType;// 稀疏矩阵的十字链表存储表示 typedef struct OLNode { int i, j; // 该非零元的行和列下标 ElemType e; // 非零元素值 struct OLNode *right, *down; // 该非零元所
数据结构-严蔚敏 清华大学：压缩存储对称矩阵
在清华大学严蔚敏教授的课程中，数据结构与C语言紧密关联，通过压缩存储来高效管理数据。" 在数据结构的学习中，首先我们需要理解基本的概念和术语。数据（Data）是指在计算机中存储和处理的信息。数据结构（Data ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值