精华内容
下载资源
问答
  • 压缩包中为 十字链表法创建图的 C 文件源文件,及对应的PPT 博客《【经典算法实现 30】图的创建 --- 十字链表法》 链接:https://blog.csdn.net/Ciellee/article/details/108199838
  • 数据结构课程设计 十字链表稀疏矩阵相加 本课程设计主要实现在十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行相加,操作,最后输出运算后的结果。稀疏矩阵采用十字链表表示,并在不同的存储结构下,求两个具有...
  • 实现了从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构(m、n分别表示矩阵行数和列数;i, j为非零元素行号和列号)和十字链表的转置并将转置后的三元组到另一字符文件中
  • 十字链表

    千次阅读 多人点赞 2019-04-26 11:26:29
    有需求才有供应,很多东西,都是为了解决实际问题才出现的,项目中出现了很多稀疏矩阵,而且需要对他们进行运算,而十字链表就是为了解决稀疏矩阵而出现的一种数据结构。 稀疏矩阵     ~~~~&...

         ~~~~     有需求才有供应,很多东西,都是为了解决实际问题才出现的,项目中出现了很多稀疏矩阵,而且需要对他们进行运算,而十字链表就是为了解决稀疏矩阵而出现的一种数据结构。

    稀疏矩阵

         ~~~~     稀疏矩阵(英语:sparse matrix),在数值分析中,是其元素大部分为零的矩阵。反之,如果大部分元素都非零,则这个矩阵是稠密的,通常这个系数被认为是5%。在科学与工程领域中求解线性模型时经常出现大型的稀疏矩阵。
         ~~~~     在使用计算机存储和操作稀疏矩阵时,经常需要修改标准算法以利用矩阵的稀疏结构。由于其自身的稀疏特性,通过压缩可以大大节省稀疏矩阵的内存代价。更为重要的是,由于过大的尺寸,标准的算法经常无法操作这些稀疏矩阵。

    三元组

         ~~~~     对于矩阵,我们第一想法就是使用二维数组来存储,但是稀疏矩阵的元素大部分都是零,而且稀疏矩阵的尺寸一般都比较大,这个时候我们如果直接使用二维数组,会浪费很多的空间,所有通常我们需要对稀疏矩阵进行压缩,三元组就是一种稀疏矩阵压缩保存的方法。
         ~~~~     三元组是指形如 ( ( x , y ) , z ) ((x,y),z) ((x,y),z)的集合(这就是说,三元组是这样的偶,其第一个射影亦是一个偶),常简记为 ( x , y , z ) (x,y,z) (x,y,z)
         ~~~~     三元组是计算机专业的一门公共基础课程——数据结构里的概念。主要是用来存储稀疏矩阵的一种压缩方式,也叫三元组表。
         ~~~~     三元组有不同的实现方法,假设以顺序表存储结构来表示三元组,称为三元组顺序表。
    结构如下

    #defube NAXSIZE 2500
    typedef struct{
        int i, j; //该非零元的行下标和列下标
        ElemType e;
    }Triple;
    typedef struct{
        Triple data[MAXSIZE + 1];//非零三元数组标,data[0]没有使用
        int mu, nu, tu;//矩阵的行数,列数,非零元个数
    }TSMatrix;
    

         ~~~~     注意,data域中表示非零元的三元组是以行序为主序顺序排列的,如果不排序,你会发现你操作和访问数据时,时间基本都花在查询数据上了。对于三元组,我们可以进行一些运算,都是很容易实现的,比如转置,相加,相减。
         ~~~~     三元组相比十字链表的缺点(暂时只能想到这些)

    • 1、增加或减少矩阵中的非零元素,都需要进行数据的移动
    • 2、大小固定,非零数据很少时,会浪费很多的空间,过多时无法保存
    • 3、查找元素比较慢(时间复杂度)
    • 4、矩阵的运算数据较慢(时间复杂度)

    十字链表

         ~~~~     十字链表(英语:Orthogonal linked list)是计算机科学中的一种高级数据结构,在Linux内核中应用广泛。具体说,一个二维十字链表是链表的元素同时链接左右水平邻结点与上下垂直邻结点。
         ~~~~     当稀疏矩阵的非零元个数和位置在操作过程中变化较大时,就不宜使用顺序表存储结构的三元组来保存稀疏矩阵;这个时候我们采用的时十字链表。
    十字链表节点结构

    typedef struct OLNode {    
         int  LineNumber, ColumneNumber;          //行号与列号     
         ElemType value;        //值     
         struct OLNode *right, *down;  //同行、同列下一个元素的指针     
    }OLNode, *OList;
    typedef struct{
        OList *rhead, *chead;    //行和列链表头指针向量基址
        int mu,nu,tu;            //稀疏矩阵的行数,列数和非零元个数
    }CrossList;
    

         ~~~~     每一个非零元可用一个含5个域的节点表示,其中i,j和e这3个域分别表示该非零元所在的行、列和非零元的值,向右域right用以链接同一行中下一个非零元,向下域down用来链接同一列下一个非零元,同一行的非零元通过right链接形成一个线性链表,同一列的非零元通过down链接形成一个线性表,每个非零元既是某个行链表中的节点,也是某一个列链表中的节点,整个矩阵构成了一个十字交叉的链表,而样的链表存储结构称为十字链表。
    在这里插入图片描述
    附上十字链表实现(百度抄的)

    #include <malloc.h>
    #include <stdio.h>
    /*十字链表的结构类型定义如下:*/
    typedef struct OLNode
    {
        int row,col; /*非零元素的行和列下标*/
        int value;
        struct OLNode *right; /*非零元素所在行表、列表的后继链域*/
        struct OLNode *down;
    } OLNode, *OLink;
    typedef struct
    {
        OLink *row_head; /*行、列链表的头指针向量*/
        OLink *col_head;
        int m,n,len; /*稀疏矩阵的行数、列数、非零元素的个数*/
    } CrossList;
    /*建立稀疏矩阵的十字链表的算法*/
    void CreateCrossList(CrossList *M)
    {
        int m, n, t, i, j, e;
        OLNode* p;
        OLNode* q;
        /*采用十字链表存储结构,创建稀疏矩阵M*/
         
    scanf("%d%d%d", &m,&n,&t); /*输入M的行数,列数和非零元素的个数*/
        M->m=m;
        M->n=n;
        M->len=t;
        if(!(M->row_head=(OLink *)malloc(m*sizeof(OLink))))
            exit(OVERFLOW);
        if(!(M->col_head=(OLink * )malloc(n*sizeof(OLink))))
            exit(OVERFLOW);
        /*初始化行、列,头指针指向量,各行、列链表为空的链表*/
        for(int h=0; h<m+1; h++)
        {
            M->row_head[h] = NULL;
        }
        for(int t=0; t<n+1; t++)
        {
            M->col_head[t] = NULL;
        }
        for(
    scanf("%d%d%d", &i,&j,&e); e!=0; scanf("%d%d%d", &i,&j,&e))
        {
            if(!(p=(OLNode *)malloc(sizeof(OLNode))))
                exit(
    OVERFLOW);
            p->row=i;
            p->col=j;
            p->value=e; /*生成结点*/
            if(M->row_head[i]==NULL)
                M->row_head[i]=p;
            p->right=NULL;
            else
            {
                /*寻找行表中的插入位置*/
                for(q=M->row_head[i]; q->right&&q->right->col<j; q=q->right); /*空循环体*/
                p->right=q->right;
                q->right=p; /*完成插入*/
            }
            if(M->col_head[j]==NULL)
                M->col_head[j]=p;
            p->down=NULL;
            else
            {
                /*寻找列表中的插入位置*/
                for(q=M->col_head[j]; q->down&&q->down->row<i; q=q->down); /*空循环体*/
                p->down=q->down;
                q->down=p; /*完成插入*/
            }
        }
    }
    
    展开全文
  • 图的十字链表C语言实现
  • 有向图的十字链表

    2016-09-03 15:54:23
    有向图的十字链表表示,包括建图,添加弧,删除弧,以邻接的格式打印图(其中包括两种形式:1,同尾的弧构成条 2,同头的弧构成条)c ++ 描述
  • 在学习《数据结构(C语言版)》中第五章稀疏矩阵时,课本提示使用十字链表实现矩阵相加,没能运行,于是自己调试实现了下,希望对大家有帮助
  • 用C++编写的稀疏矩阵乘法运算,稀疏矩阵采用十字链表存储及计算
  • 因此本文提出十字链表方法,将网络的拓扑结构与数值信息存于十字链表中,使其独立于计算,能保证数据的可重用性和灵活性。这种方法适用于与拓扑相关密切的电力系统计算,本文就潮流计算作简单介绍。
  • 广义表 三元组表 十字链表 c语言描述 建立稀疏矩阵的三元组表的算法、按矩阵的列序转置算法、按矩阵的行序转置算法 建立稀疏矩阵的十字链表的算法、输出稀疏矩阵十字链表的算法 求广义表的表头、求广义表的表尾、求...
  • 十字链表实现稀疏矩阵的加法
  • 十字链表数据结构

    2012-12-09 23:15:17
    十字链表 理论有无线的长度,数据结构作业,
  • 图的十字链表存储法详解

    千次阅读 2020-04-15 12:38:45
    前面介绍了图的邻接表存储法,本节继续讲解图的另一种链式存储结构——十字链表法。 与邻接表不同,十字链表法仅适用于存储有向图和有向网。不仅如此,十字链表法还改善了邻接表计算图中顶点入度的问题。 十字链表...

    前面介绍了邻接表存储法,本节继续讲解图的另一种链式存储结构——十字链表法。

    与邻接表不同,十字链表法仅适用于存储有向图和有向网。不仅如此,十字链表法还改善了邻接表计算图中顶点入度的问题。

    十字链表存储有向图(网)的方式与邻接表有一些相同,都以图(网)中各顶点为首元节点建立多条链表,同时为了便于管理,还将所有链表的首元节点存储到同一数组(或链表)中。

    其中,建立个各个链表中用于存储顶点的首元节点结构如图 1 所示:

    十字链表中首元节点结构示意图

                                                             图 1 十字链表中首元节点结构示意图


    从图 1 可以看出,首元节点中有一个数据域和两个指针域(分别用 f

    展开全文
  • 十字链表存储稀疏矩阵,可以起到节省空间的作用。 十字链表作为多重链表的一种,其结点分为两种: 类型1:数据域为另一个单链表的头指针。 类型2:数据域为待存储的数据。 其中,“十字”体现在:每一个存储...

    一、介绍

    用十字链表存储稀疏矩阵,可以起到节省空间的作用。

    十字链表作为多重链表的一种,其结点分为两种:

    类型1:数据域为另一个单链表的头指针。

    类型2:数据域为待存储的数据。

    其中,“十字”体现在:每一个存储数据的节点都属于两个单链表,从而构成十字形。

     

    用十字链表表示的矩阵,有着以下特征:

    1、整体的头指针指向最初的头结点,该头结点一般用于存储矩阵的行数、列数以及其中包含非0元素的数量。

    2、由最初的头结点分别横向、纵向展开两个单链表,这两个链表中的每个结点都为类型1。

    3、这两个链表中的每个结点代表特定的行或列,引出单链表。

    4、每个用于储存矩阵元素的类型2结点都属于某两个类型1结点引出的单链表。由此可标记元素在矩阵中的具体位置。

    二、实现

    .general.h:总声明。

    #ifndef _GEN_H_
        #define _GEN_H_
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    typedef unsigned int Cursor;
    #define ERROR 0xABCDEF
    typedef int ElemType;
    
    #endif

    LinkGen.h:十字链表和基本的遍历函数声明。

    #ifndef _LINK_GEN_H_
        #define _LINK_GEN_H_
    #include ".general.h"
    
    /*Structure Declaration*/
    enum Type {HEAD, UNIT, START};
    typedef struct GNode *GPos;
    typedef struct GNode *GLink;
    struct GNode {
        enum Type tag;
        union {
            GLink head;
            struct {
                Cursor row;
                Cursor column;
                ElemType value;
            } unit;
        } region;
        GPos right;
        GPos down;
    };
    
    /*Function Declaration*/
    //向右遍历
    GPos GLocateRight(GLink start, Cursor subs);
    //向下遍历
    GPos GLocateDown(GLink start, Cursor subs);
    
    #endif

    LinkGen.c:函数实现。

    #include "LinkGen.h"
    
    GPos GLocateRight(GLink start, Cursor subs)
    {
        GPos ptr = start;
        for(int i = 0; i < subs; i++) {
            if(!ptr->right)
                return NULL;
            else 
                ptr = ptr->right;
        }
        return ptr;
    }
    
    GPos GLocateDown(GLink start, Cursor subs)
    {
        GPos ptr = start;
        for(int i = 0; i < subs; i++) {
            if(!ptr->down)
                return NULL;
            else 
                ptr = ptr->down;
        }
        return ptr;
    }

    Matrix.h:声明矩阵和相关函数。

    #ifndef _MATRIX_H_
        #define _MATRIX_H_
    #include "LinkGen.h"
    
    /*Structure Declaration*/
    typedef GLink Matrix;
    
    /*Function Declaration*/
    //创建矩阵
    Matrix CreateMatrix(Cursor MaxRow, Cursor MaxCol);
    //插入矩阵中的元素
    bool InsertUnit(Matrix M, ElemType E, Cursor Row, Cursor Column);
    //打印矩阵
    bool PrintMatrix(Matrix M);
    //销毁矩阵
    bool DestroyMatrix(Matrix M);
    
    #endif

    Matrix.c:函数实现。

    #include "Matrix.h"
    
    Matrix CreateMatrix(Cursor MaxRow, Cursor MaxCol)
    {
        if(!MaxRow || !MaxCol)
            return NULL;
        /*Origin Node*/
        Matrix M = (Matrix) malloc(sizeof(struct GNode));
        if(!M)
            exit(EXIT_FAILURE);
        M->tag = START;
        M->region.unit.row = MaxRow;
        M->region.unit.column = MaxCol;
        M->region.unit.value = 0;
        /*Row Node*/
        GPos preR = M;
        for(int i = 0; i < MaxRow; i++) {
            GPos tmp = (GPos) malloc(sizeof(struct GNode));
            if(!tmp)
                exit(EXIT_FAILURE);
            tmp->tag = HEAD;
            tmp->region.head = NULL;
            preR->down = tmp;
            if(preR != M)
                preR->right = NULL;
            preR = preR->down;
        }
        preR->right = NULL;
        /*Column Node*/
        GPos preC = M;
        for(int i = 0; i < MaxCol; i++) {
            GPos tmp = (GPos) malloc(sizeof(struct GNode));
            tmp->tag = HEAD;
            tmp->region.head = NULL;
            preC->right = tmp;
            if(preC != M)
                preC->down = NULL;
            preC = preC->right;
        }
        preC->down = NULL;
        return M;
    }
    
    bool InsertUnit(Matrix M, ElemType E, Cursor Row, Cursor Column)
    {
        if(M->tag != START || Row > M->region.unit.row || Column > M->region.unit.column)
            return false;
        /*Allocation*/
        GPos tmp = (GPos) malloc(sizeof(struct GNode));
        if(!tmp)
            exit(EXIT_FAILURE);
        tmp->tag = UNIT;
        tmp->region.unit.row = Row;
        tmp->region.unit.column = Column;
        tmp->region.unit.value = E;
        /*Row Location*/
        GPos ptrR = GLocateDown(M, Row);
        if(ptrR->tag == HEAD && ptrR->region.head) {
            ptrR = ptrR->region.head;
            while(ptrR->right && !(ptrR->region.unit.column < Column && ptrR->down->region.unit.column > Column)) 
                ptrR = GLocateRight(ptrR, 1);
            tmp->right = ptrR->right;
            ptrR->right = tmp;
        } else {
            if(ptrR->tag != HEAD)
                return false;
            tmp->right = NULL;
            ptrR->region.head = tmp;
        }
        /*Column Location*/
        GPos ptrC = GLocateRight(M, Column);
        if(ptrC->tag == HEAD && ptrC->region.head) {
            ptrC = ptrC->region.head;
            while(ptrC->down && !(ptrC->region.unit.row < Row && ptrC->down->region.unit.row > Row)) 
                ptrC = GLocateDown(ptrC, 1);
            tmp->down = ptrC->down;
            ptrC->down = tmp;
        } else {
            if(ptrC->tag != HEAD)
                return false;
            tmp->down = NULL;
            ptrC->region.head = tmp;
        }
        M->region.unit.value++;
        return true;
    }
    
    bool PrintMatrix(Matrix M)
    {
        if(M->tag != START)
            return false;
        GPos ptrR = M;
        for(int i = 0; i < M->region.unit.row; i++) {
            ptrR = GLocateDown(ptrR, 1);
            if(!ptrR)
                return false;
            GPos ptrC = ptrR->region.head;
            if(!ptrC) {
                //空行填0
                for(int j = 0; j < M->region.unit.column; j++) 
                    printf("%-2d ", 0);
                putchar('\n');
            } else {
                //行前补0
                for(int k = 1; k < ptrC->region.unit.column; k++)
                    printf("%-2d ", 0);
                //行中补0
                while(ptrC->right) {
                    printf("%-2d ", ptrC->region.unit.value);
                    int diff = ptrC->right->region.unit.column - ptrC->region.unit.column;
                    for(int k = 1; k < diff; k++) 
                        printf("%-2d ", 0);
                    putchar('\n');
                }
                //行后补0
                printf("%-2d ", ptrC->region.unit.value);
                int excess = M->region.unit.column - ptrC->region.unit.column;
                for(int k = 0; k < excess; k++)
                    printf("%-2d ", 0);
                putchar('\n');
            }
        }
        return true;
    }

    三、运行实例

    main.c

    #include "Matrix.h"
    
    int main()
    {
        Matrix M = CreateMatrix(4, 3);
        InsertUnit(M, 62, 1, 2);
        InsertUnit(M, 23, 2, 1);
        InsertUnit(M, 18, 3, 2);
        InsertUnit(M, 29, 4, 3);
        PrintMatrix(M);
        return 0;
    }

    输出:

    展开全文
  • 对于压缩存储稀疏矩阵,无论是使用三元组顺序,还是使用行逻辑链接的顺序,归根结底是使用数组存储稀疏矩阵。介于数组 “不利于插入和删除数据” 的特点,以上两种压缩存储方式都不适合解决类似 “向矩阵中添加...

    原文链接: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

    展开全文
  • 对于压缩存储稀疏矩阵,无论是使用三元组顺序,还是使用行逻辑链接的顺序,归根结底是使用数组存储稀疏矩阵。介于数组 "不利于插入和删除数据" 的特点,以上两种压缩存储方式都不适合解决类似 "...
  • c++语言,用十字链表根据输入的矩阵的行数、列数、非零元数、实现矩阵的加、减、乘、转置、求逆运算,并输出矩阵。
  • 数据结构 图 十字链表 严蔚敏 数据结构 图 十字链表 严蔚敏 数据结构 图 十字链表 严蔚敏 数据结构 图 十字链表 严蔚敏 数据结构 图 十字链表 严蔚敏
  • 十字链表 1. 十字链表图文解析 十字链表是有向图的一种存储结构 在十字链表里我们称每一条有向边为:弧 十字链表的存储结构主要包括:弧结点和顶点结点,如下图: 由以上结构组成的有向图如下: 红线:与邻接表...
  • 数据结构 图论 十字链表详解 代码 阅读之前请了解先了解邻接表邻接表基础 数据结构 上面的数组+链表可以节约一些空间和方便增删,但是我们要计算一个顶点的度还是比较麻烦,十字链表就是解决计算顶点入度(就是有...
  • 【经典算法实现 30】十字链表实现图的保存一、十字链表法1.1 画出所有顶点1.2 画出所有的边1.3 完善边与顶点的出边关系1.4 完善边与顶点的入边关系二、十字链表代码实现 之前写了这么多树的文章,本文要开始学习图了...
  • 数据结构——十字链表(C语言实现)

    千次阅读 多人点赞 2020-11-09 17:22:26
    十字链表是将邻接表和逆邻接表结合在一起的一种有向图的数据结构 十字链表的节点结构体表示的是一个节点到另一个节点的边,并且此由指出节点(from)和指入节点(to)共同使用,因此大大节省了内存。 先直观感受一下...
  • 图的十字链表存储

    2016-01-01 16:23:20
    3图的十字链表
  • 前面介绍了图的邻接表存储法,本节继续讲解图的另一种链式存储结构——十字链表法。 与邻接表不同,十字链表法仅适用于存储有向图和有向网。不仅如此,十字链表法还改善了邻接表计算图中顶点入度的问题。 十字链表...
  • 数据结构稀疏矩阵实验课程设计 /********function definition********/ int init_matrix(crosslist &one) {//initialization one.row_size=0; one.colum_size=0; one.non_zero_amount=0; one.rhead=NULL;...
  • 十字链表交换任意两个节点C源代码(C指针应用终极挑战)
  • 图存储之十字链表

    2020-10-17 15:10:51
    十字链表是有向图的一种链式存储结构,在十字链表中,对应于有向图中的每条弧有一个结点,对应于每个顶点也有一个结点。 二 十字链表 十字链表的结构分为弧结点和顶点结点,其中弧结点中有5个域:尾域和头域分别...
  • 文章目录前言一、十字链表1.画邻接表2.增加弧节点的域3.自己指向自己二、邻接多重表1.画顶点2.画边3.自己指向自己 前言 近期一直在构建算法技能树的数据,借此机会,重新把数据结构与算法又温习了一遍,在看到十字...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,479
精华内容 7,391
关键字:

十字链表