精华内容
下载资源
问答
  • 数组A[10][15]的每个元素都是占4个字节的数据,将其按列优先次序存储,若A[0][0]存储地址在起始地址为1000的内存单元中,则元素A[6][9]的地址是?答案1384 loc=1000+4*[10*(9)+(6)]=1384 这个是有公式的:A[n][ ],求...

    这个还是要记一下的

    数组A[10][15]的每个元素都是占4个字节的数据,将其按列优先次序存储,若A[0][0]存储地址在起始地址为1000的内存单元中,则元素A[6][9]的地址是?答案1384

    loc=1000+4*[10*(9)+(6)]=1384

    这个是有公式的:A[n][ ],求元素A[i][j]?


    loc=loc₀+d*[n*(j)+(i)]


    loc₀是起始地址,
    d:每个元素所占字节数
    n是数组列数
    j,i是所求元素下标

    在拿一个网上的栗子

    设有二维数组A[1…12,1…10],其每个元素占4个字节,数据按列优先顺序存储,
    第一个元素的存储地址为100,那么元素A[4,5]的存储地址为?答案304

    这里数组从1开始,所以j=5-1,i=4-1:

    loc=100+4*[12*(5-1)+(4-1)]=304

    plus:

    感觉上面没有说清楚,于是再加一点。

    当你上面的计算出错时,有没有好好的看清题目呢。为什么这个数组位置储存于自己想的不一样啊!

    仔细读题发现“按列优先”和平常的“按行优先”是不是有区别呢。答案我想大家看到这就想明白了吧!如果是按列优先当然是要用上面的n*j咯!简单吧!哈哈!

    展开全文
  • 数据结构问题:数组A【1..5,1..6】的每个元素占5个单元,将其按行优先次序储存在起始地址为1000的连续内存单元中,则A【5,5】的地址是?计算式子(4*6+5)*5-5+1000=1140这个“-5”是从哪里来的? 1000 A[1,1] A[1...

    数据结构问题:数组A【1..5,1..6】的每个元素占5个单元,将其按行优先次序储存在起始地址为1000的连续内存单元中,则A【5,5】的地址是?计算式子(4*6+5)*5-5+1000=1140这个“-5”是从哪里来的?

    1000
    A[1,1]
    A[1,2]
    A[1,3]
    A[1,4]
    A[1,5]
    A[1,6]
        +6*5
    A[2,1]
    ...
    A[2,6]
        +6*5
    A[3,1]
    ...
    A[3,6]
        +6*5
    
    A[4,1]
    ...
    A[4,6]
        +6*5
    
    A[5,1]
    ...
    A[5,5]
        +5*5
    
    1000 + (6*5)*4 + 5*5 = 1000 + 120 + 25 = 1145
    但是1145是A[5,5]之后内存单元的地址(也就是A[5,6]的首地址)。因此A[5,5]的首地址是1145-5=1140
    如果你学过汇编,就很好理解了。
    展开全文
  • 按列优先次序

    千次阅读 2018-08-15 21:50:20
    顾名思义,列优先优先按列存储,先存完第一列再存第二列,行优先同理。 C/C++中矩阵的存储为行优先,但Matlab中是列优先准则,在不同语言间读取数据时需要注意这点,同时在写Matlab时要尽量取一个二维数组的列,...

    对于一个矩阵,在内存中有两种存储顺序:

    对于下面的矩阵:

    \begin{bmatrix}11 & 12 & 13 \\21 & 22 & 23 \end{bmatrix}

    可以有两种存储方式:左为列优先,右为行优先。

    顾名思义,列优先:优先按列存储,先存完第一列再存第二列,行优先同理。

    C/C++中矩阵的存储为行优先,但Matlab中是列优先准则,在不同语言间读取数据时需要注意这点,同时在写Matlab时要尽量取一个二维数组的列,而不是行。

    扩展到N维矩阵,列优先意味着存储时第一个维度先变化,即存储顺序为(0,0,0,...)、(1,0,0,...)、(max,0,0,...)、(0,1,0,...)、(1,1,0,...),

    行优先意味着最后一个维度先变化。

    p.s:在处理数据时,说明数据的顺序需要表明1)维度安排和 2)是否是行\列优先,这两个信息缺一不可。

    p.s:caffe的Blob、numpy的array、OpenCV的Mat都是和C语言一样,是行优先的。

    p.s:貌似只有Matlab中的矩阵是列优先。

    展开全文
  • 按行优先顺序列出四维数组A[2][3][2][3]所有元素在内存中存储次序
  • 图的存储结构相比较线性表与树来说就复杂很多,对于线性表来说,是一对一的关系,所以用数组或者链表均可简单存放。树结构是一对多的关系,所以我们要将数组和链表的特性结合在一起才能更好的存放。 那么我们的图,...

    图的存储结构相比较线性表与树来说就复杂很多,对于线性表来说,是一对一的关系,所以用数组或者链表均可简单存放。树结构是一对多的关系,所以我们要将数组和链表的特性结合在一起才能更好的存放。

    那么我们的图,是多对多的情况,另外图上的任何一个顶点都可以被看作是第一个顶点,任一顶点的邻接点之间也不存在次序关系。

    仔细观察以下几张图,然后深刻领悟一下:

     

    因为任意两个顶点之间都可能存在联系,因此无法以数据元素在内存中的物理位置来表示元素之间的关系(内存物理位置是线性的,图的元素关系是平面的)。

    如果用多重链表来描述倒是可以做到,但在几节课前的树章节我们已经讨论过,纯粹用多重链表导致的浪费是无法想像的(如果各个顶点的度数相差太大,就会造成巨大的浪费)。

     

    邻接矩阵(无向图)

    考虑到图是由顶点和边或弧两部分组成,合在一起比较困难,那就很自然地考虑到分为两个结构来分别存储。

    顶点因为不区分大小、主次,所以用一个一维数组来存储是狠不错的选择。

    而边或弧由于是顶点与顶点之间的关系,一维数组肯定就搞不定了,那我们不妨考虑用一个二维数组来存储。

     

    图的邻接矩阵(Adjacency Matrix)存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息,一个二维数组(称为邻接矩阵)存储图中的边或弧的信息。

     

    我们可以设置两个数组,顶点数组为vertex[4]={V0,V1,V2,V3},边数组arc[4][4]为对称矩阵(0表示不存在顶点间的边,1表示顶点间存在边)。

     

    对称矩阵:所谓对称矩阵就是n阶矩阵的元满足a[i][j]=a[j][i](0<=i,j<=n)。即从矩阵的左上角到右下角的主对角线为轴,右上角的元与左下角相对应的元全都是相等的。

    有了这个二维数组组成的对称矩阵,我们就可以很容易地知道图中的信息:

    1. 要判定任意两顶点是否有边无边就非常容易了;
    2. 要知道某个顶点的度,其实就是这个顶点Vi在邻接矩阵中第i行(或第i列)的元素之和;
    3. 求顶点Vi的所有邻接点就是将矩阵中第i行元素扫描一遍,arc[i][j]为1就是邻接点咯。

     

    邻接矩阵(有向图)

    无向图的边构成了一个对称矩阵,貌似浪费了一半的空间,那如果是有向图来存放,会不会把资源都利用得很好呢?

     

    可见顶点数组vertex[4]={V0,V1,V2,V3},弧数组arc[4][4]也是一个矩阵,但因为是有向图,所以这个矩阵并不对称,例如由V1到V0有弧,得到arc[1][0]=1,而V0到V1没有弧,因此arc[0][1]=0。

    另外有向图是有讲究的,要考虑入度和出度,顶点V1的入度为1,正好是第V1列的各数之和,顶点V1的出度为2,正好是第V1行的各数之和。

     

    邻接矩阵(网)

    在图的术语中,我们提到了网这个概念,事实上也就是每条边上带有权的图就叫网。

     

    下面以此无向图为例,使用邻接矩阵存储,并实现深度优先遍历和广度优先遍历:

    代码如下:

    #include <stdio.h>
    
    #define MaxVex        100            //最大顶点数
    #define INFINITY    65535        //表示∞
    #define TRUE        1
    #define    FALSE        0
    typedef char        VertexType;    //顶点类型
    typedef    int            EdgeType;    //权值类型
    typedef int            Bool;
    Bool    visited[MaxVex];
    
    typedef struct {
        VertexType    vexs[MaxVex];            //顶点数组
        EdgeType    arc[MaxVex][MaxVex];    //邻接矩阵
        int    numVertexes, numEdges;            //当前图中的结点数以及边数
    }MGraph;
    
    
    //广度优先遍历需要的循环队列
    typedef struct {
        int    data[MaxVex];
        int    front, rear;
    }Queue;
    
    
    /****************************************/
    //队列的相关操作
    
    //初始化
    void InitQueue(Queue *Q)
    {
        Q->front = Q->rear = 0;
    }
    
    //入队
    void EnQueue(Queue *Q, int e)
    {
        if ((Q->rear+1)%MaxVex == Q->front)
            return ;
    
        Q->data[Q->rear] = e;
        Q->rear = (Q->rear+1)%MaxVex;
    }
    
    //判空
    Bool QueueEmpty(Queue *Q)
    {
        if (Q->front == Q->rear)
            return TRUE;
        else
            return FALSE;
    }
    
    //出队
    void DeQueue(Queue *Q, int *e)
    {
        if (Q->front == Q->rear)
            return ;
        
        *e = Q->data[Q->front];
        Q->front = (Q->front+1)%MaxVex;
    }
    /****************************************/
    
    
    //建立图的邻接矩阵
    void CreateMGraph(MGraph *G)
    {
        int i, j, k, w;
    
        printf("输入顶点数和边数: ");
        scanf("%d%d", &G->numVertexes,&G->numEdges);
        fflush(stdin);
    
        printf("==============================\n");
        printf("输入各个顶点:\n");
        for (i=0; i<G->numVertexes; ++i)
        {
            printf("顶点%d: ",i+1);
            scanf("%c", &G->vexs[i]);
            fflush(stdin);
        }
    
        for (i=0; i<G->numVertexes; ++i)
        {
            for (j=0; j<G->numVertexes; ++j)
                G->arc[i][j] = INFINITY;
        }
    
        printf("==============================\n");
        for (k=0; k<G->numEdges; ++k)
        {
            printf("输入边(vi, vj)中的下标i和j和权W: ");
            scanf("%d%d%d", &i,&j,&w);
            G->arc[i][j] = w;
            G->arc[j][i] = G->arc[i][j];
        }
    }
    
    
    //输出
    void DisMGraph(MGraph *G)
    {
        int i, j, k;
        k = G->numVertexes;
        for (i=0; i<k; ++i)
        {
            for (j=0; j<k; ++j)
            {
                printf("%5d ", G->arc[i][j]);
            }
            putchar('\n');
        }
    }
    
    
    /****************************************/
    //图的深度优先遍历
    void DFS(MGraph G, int i)
    {
        int j;
        visited[i] = TRUE;
        printf("%c ",    G.vexs[i]);
    
        for (j=0; j<G.numVertexes; ++j)
        {
            if (G.arc[i][j]!=INFINITY  &&  !visited[j])
                DFS(G, j);
        }
    }
    
    void DFSTraverse(MGraph G)
    {
        int i;
        for (i=0; i<G.numVertexes; ++i)
            visited[i] = FALSE;
    
        for (i=0; i<G.numVertexes; ++i)
        {
            if (!visited[i])
                DFS(G, i);
        }
    
    }
    
    
    //图的广度优先遍历
    void BFSTraverse(MGraph *G)
    {
        int i, j;
        Queue Q;
    
        for (i=0; i<G->numVertexes; ++i)
            visited[i] = FALSE;
    
        InitQueue(&Q);
    
        for (i=0; i<G->numVertexes; ++i)
        {
            if (!visited[i])
            {
                visited[i] = TRUE;
                printf("%c ", G->vexs[i]);
                EnQueue(&Q, i);
    
                while (!QueueEmpty(&Q))
                {
                    DeQueue(&Q, &i);
                    for (j=0; j<G->numVertexes; ++j)
                    {
                        if (!visited[j] && G->arc[i][j]!=INFINITY)
                        {
                            visited[j] = TRUE;
                            printf("%c ", G->vexs[j]);
                            EnQueue(&Q, j);
                        }
                    }
                }
            }
        }
    }
    /****************************************/
    
    //程序入口
    int main(){
        MGraph G;
    
        CreateMGraph(&G);
    
        printf("\n图的深度优先遍历为: ");
        DFSTraverse(G);    
    
        printf("\n图的广度优先遍历为: ");
        BFSTraverse(&G);
    
        printf("\n");
    
        return 0;
    }

     

    运行结果截图:

     

    转载于:https://www.cnblogs.com/zhangming-blog/p/5412085.html

    展开全文
  • 图的存储结构相比较线性表与树来说就复杂很多,对于线性表来说,是一对一的关系,所以用数组或者链表均可简单存放。树结构是一对多的关系,所以我们要将数组和链表的特性结合在一起才能更好的存放。 那么我们的图,...
  • 其实我们知道内存中是以对齐方式存储的,只是我们往往定义一个类的时候对于其中的成员变量很随意的就写上,当然这对程序(类的)实现功能没什么影响,但这确实会对内存产生不必要的浪费 cat class.cpp #include ...
  • 内存地址的计算

    2019-09-25 09:40:09
    数组A[0..5,0..6]的每个元素占五个字节,将其按列优先次序存储在起始地址为1000的内存单元中,则元素A[5,5]的地址是( )。 A. 1175 B. 1180 C. 1205 D. 1210 二维数组表达:A[6][7] (可以当做六列七行) 题目所述...
  • 图的广度优先搜索算法思想: 设初始状态时图中的所有顶点都未被访问,则: (1):从图中某个顶点i出发,访问i; (2):访问i的所有相邻接且未被访问的所有顶点i1, i2, i3...in; (3):以i1, i2, i3...in的...
  • 字节存放次序

    2019-03-27 22:47:00
    1.big endian 高位优先 将最重要的字节存放在地址最低的存储器单元. 2.little endian 低位优先 将最重要的字节存放在地址最高的存储器单元. 解释都是来自编程思想.概念有点模糊,什么是地址最高,什么是地址最低...
  • 数据结构 线性表试题

    2020-10-04 16:50:32
    数据结构 线性表试题 数组A[1…5,1…6]每个元素占5个单元,将其按行优先次序存储在起始地址为1000的连续的内存单元中,则元素A[5,5]的地址为: A. 1120 B. 1125 C. 1140 D. 1145
  • 线性结构习题及解析

    千次阅读 2020-06-05 09:22:58
    数组A[1…5,1…6]每个元素占5个单元,将其按行优先次序存储在起始地址为1000的连续的内存单元中,则元素A[5,5]的地址为: 1120 1125 1140 1145 解析: 2-2 对于顺序存储的长度为N的线性表,访问结点和...
  • NowCoder(5选)

    2019-09-19 20:15:57
    1、下面哪项是数组优于链表的特点? 正确答案: D A 方便删除 B 方便插入 ...3:插入和删除是链表优于数组,数组需要移动被删除或者插入...2、数组A[0…5,0…6]的每个元素占5个字节,将其按列优先次序存储在起始...
  • 已知数组A[0..5,0..7]的每个元素占6个字节存储,将其按行优先次序存储在起始地址为1000的连续的内存单元中,则数组A的体积(即存储量)为_______个字节,元素A[1,4]的起始地址为_______。(288 1072)5.广义表((a,b),(c...
  • 2020-09-15

    2020-12-06 23:13:09
    数组A[1…5,1…6]每个元素占5个单元,将其按行优先次序存储在起始地址为1000的连续的内存单元中,则元素A[5,5]的地址为1140:五行六列,465+5*5-5=1140. 对于顺序存储长度为N的线性表,访问结点和增加结点的时间...
  • 二叉树结构简单,存储效率高,算法简单,每个结点至多有两个子树,两个子树有左右之分,次序不能颠倒。 二叉树的存储结构分为:顺序存储结构和链式存储结构。 1.顺序存储结构 把一棵满二叉树自上而下,从左到右...
  • 1、所谓图的遍历就是按照某种次序访问图的每一顶点一次仅且一次。 2、实现bfs和dfs都需要解决的一个问题就是如何存储图。一般有两种方法:邻接矩阵和邻接表。这里为简单起 见,均采用邻接矩阵存储,说白了也...
  • [原创]本matlab代码是...这种编码次序是自适应确定的,不需要任何额外的存储空间,而且在到达指定压缩比时能够编码更多的重要系数。实验结果表明,对比原来的SPIHT 算法,该方法能提高峰值信嗓比并改善主观视觉感受。
  • 特殊矩阵的压缩存储

    2020-07-17 22:43:23
    压缩存储:指多个值相同的元素只分配一个存储空间, 对零元素不分配存储空间。 特殊矩阵:指具有许多相同矩阵元素或零元素,并且这些相同...行优先,以这样的次序存放元素​​​​ 2 三角矩阵 三角矩阵若对一个.
  • 1、栈和队列都是线性结构,对于栈只能在____栈顶______插入或删除元素;...7、已知数组A[9,9]的每个元素占5个存储单元,将其按优先次序存储在其始地址为1000的连续存储单元中,则 元素A[6,8]的地址为 1310 。
  • 虽然术语暗指二维数组的行和列,即矩阵,但是可以将这些次序推广到任何维度的数组:例如在 ...支持多维数组的编程语言或其标准库通常具有这些数组的行优先(主)或列优先(主)存储顺序。在C / C ++ (用于C风格的数组...
  •  虽然术语暗指二维数组的行和列,即矩阵,但是可以将这些次序推广到任何维度的数组:例如在 row-major order中,行... 支持多维数组的编程语言或其标准库通常具有这些数组的行优先(主)或列优先(主)存储顺序。在...
  • 西安电子科技大学数据结构期中考试试题 ...3. 数组A[0…5,0…6]的每个元素占5个字节,将其按列优先次序存储在起始地址为1000的内存单元中,则元素A[5,5]的地址为 。 A. 1175 B. 1180 C. 1205 D.1210
  • STL中的优先队列总结

    千次阅读 2014-06-05 14:25:23
    优先队列(priority_queue)元素的次序是由作用于所存储的值对上的某种谓词决定的的有序队列”
  • 1、所谓图的遍历就是按照某种次序访问图的每一顶点一次仅且一次。 2、实现bfs和dfs都需要解决的一个问题就是如何存储图。一般有两种方法:邻接矩阵和邻接表。这里为简单起见,均采用邻接矩阵存储,说白了 也...
  • 1、所谓图的遍历就是按照某种次序访问图的每一顶点一次仅且一次。 2、实现bfs和dfs都需要解决的一个问题就是如何存储图。一般有两种方法:邻接矩阵和邻接表。这里为简单起 见,均采用邻接矩阵存储,说白了也...
  • 注意:①BFS和DFS都是对图的遍历(按照某种次序访问图的每一顶点一次仅且一次)  ②存储图的两种方式:邻接表和邻接矩阵(本质就是二维数组) 一、BFS  ①也就是我们说的广度搜索算法  ②实现方式:利用队列和...
  • 广度优先搜索(BFS)

    2017-08-10 20:04:41
    一、概述广度优先搜索英文全称为(breadth-first search,bfs),为图的一种遍历方式,所采用的策略可概况为越早被访问到的顶点,其邻居顶点越早被访问。于是,从根顶点s的BFS搜索,将首先访问顶点s;再依次访问s所有...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 191
精华内容 76
关键字:

优先次序存储