第五章 数组和广义表

最新推荐文章于 2021-08-30 11:01:39 发布
最新推荐文章于 2021-08-30 11:01:39 发布
阅读量1k 收藏 2
点赞数
分类专栏： 数据结构(C语言) 文章标签： null struct layer 算法 存储 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Beta3/article/details/1651039
版权

5.18

void RSh(int A[n],int k)//把数组A的元素循环右移k位,只用一个辅助存储空间
{
  for(i=1;i<=k;i++)
    if(n%i==0&&k%i==0) p=i;//求n和k的最大公约数p
  for(i=0;i<p;i++)
  {
    j=i;l=(i+k)%n;temp=A[i];
    while(l!=i)
    {
      A[j]=temp;
      temp=A[l];
      A[l]=A[j];
      j=l;l=(j+k)%n;
    }// 循环右移一步
    A[i]=temp;
  }//for
}//RSh
分析:要把A的元素循环右移k位,则A[0]移至A[k],A[k]移至A[2k]......直到最终回到A[0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以A[0],A[1],...A[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个"循环链"上面.举例如下:
n=15,k=6,则p=3.
第一条链:A[0]->A[6],A[6]->A[12],A[12]->A[3],A[3]->A[9],A[9]->A[0].
第二条链:A[1]->A[7],A[7]->A[13],A[13]->A[4],A[4]->A[10],A[10]->A[1].
第三条链:A[2]->A[8],A[8]->A[14],A[14]->A[5],A[5]->A[11],A[11]->A[2].
恰好使所有元素都右移一次.
虽然未经数学证明,但相信上述规律应该是正确的.

5.19

void Get_Saddle(int A[m][n])//求矩阵A中的马鞍点
{
  for(i=0;i<m;i++)
  {
    for(min=A[i][0],j=0;j<n;j++)
      if(A[i][j]<min) min=A[i][j]; //求一行中的最小值
    for(j=0;j<n;j++)
      if(A[i][j]==min) //判断这个(些)最小值是否鞍点
      {
        for(flag=1,k=0;k<m;k++)
          if(min<A[k][j]) flag=0;
        if(flag)
          printf("Found a saddle element!/nA[%d][%d]=%d",i,j,A[i][j]);
      }
  }//for
}//Get_Saddle

5.20
本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.

5.21

void TSMatrix_Add(TSMatrix A,TSMatrix B,TSMatrix &C)//三元组表示的稀疏矩阵加法
{
  C.mu=A.mu;C.nu=A.nu;C.tu=0;
  pa=1;pb=1;pc=1;
  for(x=1;x<=A.mu;x++) //对矩阵的每一行进行加法
  {
    while(A.data[pa].i<x) pa++;
    while(B.data[pb].i<x) pb++;
    while(A.data[pa].i==x&&B.data[pb].i==x)//行列值都相等的元素
    {
      if(A.data[pa].j==B.data[pb].j)
      {
        ce=A.data[pa].e+B.data[pb].e;
        if(ce) //和不为0
        {
          C.data[pc].i=x;
          C.data[pc].j=A.data[pa].j;
          C.data[pc].e=ce;
          pa++;pb++;pc++;
        }
      }//if
      else if(A.data[pa].j>B.data[pb].j)
      {
        C.data[pc].i=x;
        C.data[pc].j=B.data[pb].j;
        C.data[pc].e=B.data[pb].e;
        pb++;pc++;
      }
      else
      {
        C.data[pc].i=x;
        C.data[pc].j=A.data[pa].j;
        C.data[pc].e=A.data[pa].e
        pa++;pc++;
      }
    }//while
    while(A.data[pa]==x) //插入A中剩余的元素(第x行)
    {
      C.data[pc].i=x;
      C.data[pc].j=A.data[pa].j;
      C.data[pc].e=A.data[pa].e
      pa++;pc++;
    }
    while(B.data[pb]==x) //插入B中剩余的元素(第x行)
    {
      C.data[pc].i=x;
      C.data[pc].j=B.data[pb].j;
      C.data[pc].e=B.data[pb].e;
      pb++;pc++;
    }
  }//for
  C.tu=pc;
}//TSMatrix_Add

5.22

void TSMatrix_Addto(TSMatrix &A,TSMatrix B)//将三元组矩阵B加到A上
{
  for(i=1;i<=A.tu;i++)
    A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置
  pa=MAXSIZE-A.tu+1;pb=1;pc=1;
  for(x=1;x<=A.mu;x++) //对矩阵的每一行进行加法
  {
    while(A.data[pa].i<x) pa++;
    while(B.data[pb].i<x) pb++;
    while(A.data[pa].i==x&&B.data[pb].i==x)//行列值都相等的元素
    {
      if(A.data[pa].j==B.data[pb].j)
      {
        ne=A.data[pa].e+B.data[pb].e;
        if(ne) //和不为0
        {
          A.data[pc].i=x;
          A.data[pc].j=A.data[pa].j;
          A.data[pc].e=ne;
          pa++;pb++;pc++;
        }
      }//if
      else if(A.data[pa].j>B.data[pb].j)
      {
        A.data[pc].i=x;
        A.data[pc].j=B.data[pb].j;
        A.data[pc].e=B.data[pb].e;
        pb++;pc++;
      }
      else
      {
        A.data[pc].i=x;
        A.data[pc].j=A.data[pa].j;
        A.data[pc].e=A.data[pa].e
        pa++;pc++;
      }
    }//while
    while(A.data[pa]==x) //插入A中剩余的元素(第x行)
    {
      A.data[pc].i=x;
      A.data[pc].j=A.data[pa].j;
      A.data[pc].e=A.data[pa].e
      pa++;pc++;
    }
    while(B.data[pb]==x) //插入B中剩余的元素(第x行)
    {
      A.data[pc].i=x;
      A.data[pc].j=B.data[pb].j;
      A.data[pc].e=B.data[pb].e;
      pb++;pc++;
    }
  }//for
  A.tu=pc;
  for(i=A.tu;i<MAXSIZE;i++) A.data[i]={0,0,0}; //清除原来的A中记录
}//TSMatrix_Addto

5.23

typedef struct{
                    int j;
                    int e;
                  } DSElem;

typedef struct{
                DSElem data[MAXSIZE];
                int cpot[MAXROW];//这个向量存储每一行在二元组中的起始位置
                int mu,nu,tu;
              } DSMatrix; //二元组矩阵类型

Status DSMatrix_Locate(DSMatrix A,int i,int j,int &e)//求二元组矩阵的元素A[i][j]的值e
{
  for(s=cpot[i];s<cpot[i+1]&&A.data[s].j!=j;s++);//注意查找范围
  if(A.data[s].i==i&&A.data[s].j==j) //找到了元素A[i][j]
  {
    e=A.data[s];
    return OK;
  }
  return ERROR;
}//DSMatrix_Locate

5.24

typedef struct{
                    int seq; //该元素在以行为主序排列时的序号
                    int e;
                  } SElem;

typedef struct{
                    SElem data[MAXSIZE];
                    int mu,nu,tu;
                  } SMatrix; //单下标二元组矩阵类型

Status SMatrix_Locate(SMatrix A,int i,int j,int &e)//求单下标二元组矩阵的元素A[i][j]的值e
{
  s=i*A.nu+j+1;p=1;
  while(A.data[p].seq<s) p++; //利用各元素seq值逐渐递增的特点
  if(A.data[p].seq==s) //找到了元素A[i][j]
  {
    e=A.data[p].e;
    return OK;
  }
  return ERROR;
}//SMatrix_Locate

5.25

typedef enum{0,1} bool;

typedef struct{
                    int mu,nu;
                    int elem[MAXSIZE];
                    bool map[mu][nu];
                  } BMMatrix; //用位图表示的矩阵类型

void BMMatrix_Add(BMMatrix A,BMMatrix B,BMMatrix &C)//位图矩阵的加法
{
  C.mu=A.mu;C.nu=A.nu;
  pa=1;pb=1;pc=1;
  for(i=0;i<A.mu;i++) //每一行的相加
    for(j=0;j<A.nu;j++) //每一个元素的相加
    {
      if(A.map[i][j]&&B.map[i][j]&&(A.elem[pa]+B.elem[pb]))//结果不为0
      {
        C.elem[pc]=A.elem[pa]+B.elem[pb];
        C.map[i][j]=1;
        pa++;pb++;pc++;
      }
      else if(A.map[i][j]&&!B.map[i][j])
      {
        C.elem[pc]=A.elem[pa];
        C.map[i][j]=1;
        pa++;pc++;
      }
      else if(!A.map[i][j]&&B.map[i][j])
      {
        C.elem[pc]=B.elem[pb];
        C.map[i][j]=1;
        pb++;pc++;
      }
    }
}//BMMatrix_Add

5.26

void Print_OLMatrix(OLMatrix A)//以三元组格式输出十字链表表示的矩阵
{
  for(i=0;i<A.mu;i++)
  {
    if(A.rhead[i])
      for(p=A.rhead[i];p;p=p->right) //逐次遍历每一个行链表
        printf("%d %d %d/n",i,p->j,p->e;
  }
}//Print_OLMatrix

5.27

void OLMatrix_Add(OLMatrix &A,OLMatrix B)//把十字链表表示的矩阵B加到A上
{
  for(j=1;j<=A.nu;j++) cp[j]=A.chead[j]; //向量cp存储每一列当前最后一个元素的指针
  for(i=1;i<=A.mu;i++)
  {
    pa=A.rhead[i];pb=B.rhead[i];pre=NULL;
    while(pb)
    {
      if(pa==NULL||pa->j>pb->j) //新插入一个结点
      {
        p=(OLNode*)malloc(sizeof(OLNode));
        if(!pre) A.rhead[i]=p;
        else pre->right=p;
        p->right=pa;pre=p;
        p->i=i;p->j=pb->j;p->e=pb->e; //插入行链表中
        if(!A.chead[p->j])
        {
          A.chead[p->j]=p;
          p->down=NULL;
        }
        else
        {
          while(cp[p->j]->down) cp[p->j]=cp[p->j]->down;
          p->down=cp[p->j]->down;
          cp[p->j]->down=p;
        }
        cp[p->j]=p; //插入列链表中
      }//if
      else if(pa->j<pb->j)
      {
        pre=pa;
        pa=pa->right;
      } //pa右移一步
      else if(pa->e+pb->e)
      {
        pa->e+=pb->e;
        pre=pa;pa=pa->right;
        pb=pb->right;
      } //直接相加
      else
      {
        if(!pre) A.rhead[i]=pa->right;
        else pre->right=pa->right;
        p=pa;pa=pa->right; //从行链表中删除
        if(A.chead[p->j]==p)
          A.chead[p->j]=cp[p->j]=p->down;
        else cp[p->j]->down=p->down; //从列链表中删除
        free (p);
      }//else
    }//while
  }//for
}//OLMatrix_Add
分析:本题的具体思想在课本中有详细的解释说明.

5.28

void MPList_PianDao(MPList &L)//对广义表存储结构的多元多项式求第一变元的偏导
{
  for(p=L->hp->tp;p&&p->exp;pre=p,p=p->tp)
  {
    if(p->tag) Mul(p->hp,p->exp);
    else p->coef*=p->exp; //把指数乘在本结点或其下属结点上
    p->exp--;
  }
  pre->tp=NULL;
  if(p) free (p); //删除可能存在的常数项
}//MPList_PianDao

void Mul(MPList &L,int x)//递归算法,对多元多项式L乘以x
{
  for(p=L;p;p=p->tp)
  {
    if(!p->tag) p->coef*=x;
    else Mul(p->hp,x);
  }
}//Mul
    
5.29

void MPList_Add(MPList A,MPList B,MPList &C)//广义表存储结构的多项式相加的递归算法
{
  C=(MPLNode*)malloc(sizeof(MPLNode));
  if(!A->tag&&!B->tag) //原子项,可直接相加
  {
    C->coef=A->coef+B->coef;
    if(!C->coef)
    {
      free(C);
      C=NULL;
    }
  }//if
  else if(A->tag&&B->tag) //两个多项式相加
  {
    p=A;q=B;pre=NULL;
    while(p&&q)
    {
      if(p->exp==q->exp)
      {
        C=(MPLNode*)malloc(sizeof(MPLNode));
        C->exp=p->exp;
        MPList_Add(A->hp,B->hp,C->hp);
        pre->tp=C;pre=C;
        p=p->tp;q=q->tp;
      }
      else if(p->exp>q->exp)
      {
        C=(MPLNode*)malloc(sizeof(MPLNode));
        C->exp=p->exp;
        C->hp=A->hp;
        pre->tp=C;pre=C;
        p=p->tp;
      }
      else
      {
        C=(MPLNode*)malloc(sizeof(MPLNode));
        C->exp=q->exp;
        C->hp=B->hp;
        pre->tp=C;pre=C;
        q=q->tp;
      }
    }//while
    while(p)
    {
      C=(MPLNode*)malloc(sizeof(MPLNode));
      C->exp=p->exp;
      C->hp=p->hp;
      pre->tp=C;pre=C;
      p=p->tp;
    }
    while(q)
    {
      C=(MPLNode*)malloc(sizeof(MPLNode));
      C->exp=q->exp;
      C->hp=q->hp;
      pre->tp=C;pre=C;
      q=q->tp;
    } //将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题
  }//else if
  else if(A->tag&&!B->tag) //多项式和常数项相加
  {
    x=B->coef;
    for(p=A;p->tp->tp;p=p->tp);
    if(p->tp->exp==0) p->tp->coef+=x; //当多项式中含有常数项时,加上常数项
    if(!p->tp->coef)
    {
      free(p->tp);
      p->tp=NULL;
    }
    else
    {
      q=(MPLNode*)malloc(sizeof(MPLNode));
      q->coef=x;q->exp=0;
      q->tag=0;q->tp=NULL;
      p->tp=q;
    } //否则新建常数项,下同
  }//else if
  else
  {
    x=A->coef;
    for(p=B;p->tp->tp;p=p->tp);
    if(p->tp->exp==0) p->tp->coef+=x;
    if(!p->tp->coef)
    {
      free(p->tp);
      p->tp=NULL;
    }
    else
    {
      q=(MPLNode*)malloc(sizeof(MPLNode));
      q->coef=x;q->exp=0;
      q->tag=0;q->tp=NULL;
      p->tp=q;
    }
  }//else
}//MPList_Add

5.30

int GList_Getdeph(GList L)//求广义表深度的递归算法
{
  if(!L->tag) return 0; //原子深度为0
  else if(!L) return 1; //空表深度为1
  m=GList_Getdeph(L->ptr.hp)+1;
  n=GList_Getdeph(L->ptr.tp);
  return m>n?m:n;
}//GList_Getdeph

5.31

void GList_Copy(GList A,GList &B)//复制广义表的递归算法
{
  if(!A->tag) //当结点为原子时,直接复制
  {
    B->tag=0;
    B->atom=A->atom;
  }
  else //当结点为子表时
  {
    B->tag=1;
    if(A->ptr.hp)
    {
      B->ptr.hp=malloc(sizeof(GLNode));
      GList_Copy(A->ptr.hp,B->ptr.hp);
    } //复制表头
    if(A->ptr.tp)
    {
      B->ptr.tp=malloc(sizeof(GLNode));
      GList_Copy(A->ptr.tp,B->ptr.tp);
    } //复制表尾
  }//else
}//GList_Copy

5.32

int GList_Equal(GList A,GList B)//判断广义表A和B是否相等,是则返回1,否则返回0
{ //广义表相等可分三种情况:
  if(!A&&!B) return 1; //空表是相等的
  if(!A->tag&&!B->tag&&A->atom==B->atom) return 1;//原子的值相等
  if(A->tag&&B->tag)
    if(GList_Equal(A->ptr.hp,B->ptr.hp)&&GList_Equal(A->ptr.tp,B->ptr.tp))
      return 1; //表头表尾都相等
  return 0;
}//GList_Equal

5.33

void GList_PrintElem(GList A,int layer)//递归输出广义表的原子及其所在层次,layer表示当前层次
{
  if(!A) return;
  if(!A->tag) printf("%d %d/n",A->atom,layer);
  else
  {
    GList_PrintElem(A->ptr.hp,layer+1);
    GList_PrintElem(A->ptr.tp,layer); //注意尾表与原表是同一层次
  }
}//GList_PrintElem

5.34

void GList_Reverse(GList A)//递归逆转广义表A
{
  if(A->tag&&A->ptr.tp) //当A不为原子且表尾非空时才需逆转
  {
    D=C->ptr.hp;
    A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D; //交换表头和表尾
    GList_Reverse(A->ptr.hp);
    GList_Reverse(A->ptr.tp); //逆转表头和表尾
  }
}//GList_Reverse

5.35

Status Create_GList(GList &L)//根据输入创建广义表L,并返回指针
{
  scanf("%c",&ch);
  if(ch==' ')
  {
    L=NULL;
    scanf("%c",&ch);
    if(ch!=')') return ERROR;
    return OK;
  }
  L=(GList)malloc(sizeof(GLNode));
  L->tag=1;
  if(isalphabet(ch)) //输入是字母
  {
    p=(GList)malloc(sizeof(GLNode)); //建原子型表头
    p->tag=0;p->atom=ch;
    L->ptr.hp=p;
  }
  else if(ch=='(') Create_GList(L->ptr.hp); //建子表型表头
  else return ERROR;
  scanf ("%c",&ch);
  if(ch==')') L->ptr.tp=NULL;
  else if(ch==',') Create_GList(L->ptr.tp); //建表尾
  else return ERROR;
  return OK;
}//Create_GList
分析:本题思路见书后解答.

5.36

void GList_PrintList(GList A)//按标准形式输出广义表
{
  if(!A) printf("()"); //空表
  else if(!A->tag) printf("%d",A->atom);//原子
  else
  {
    printf("(");
    GList_PrintList(A->ptr.hp);
    if(A->ptr.tp)
    {
      printf(",");
      GList_PrintList(A->ptr.tp);
    } //只有当表尾非空时才需要打印逗号
    printf(")");
  }//else
}//GList_PrintList

5.37

void GList_DelElem(GList &A,int x)//从广义表A中删除所有值为x的原子
{
  if(A->ptr.hp->tag) GList_DelElem(A->ptr.hp,x);
  else if(!A->ptr.hp->tag&&A->ptr.hp->atom==x)
  {
    q=A;
    A=A->ptr.tp;    //删去元素值为x的表头
    free(q);
    GList_DelElem(A,x);
  }
  if(A->ptr.tp) GList_DelElem(A->ptr.tp,x);
}//GList_DelElem

5.39

void GList_PrintElem_LOrder(GList A)//按层序输出广义表A中的所有元素
{
  InitQueue(Q);
  for(p=L;p;p=p->ptr.tp) EnQueue(Q,p);
  while(!QueueEmpty(Q))
  {
    DeQueue(Q,r);
    if(!r->tag) printf("%d",r->atom);
    else
      for(r=r->ptr.hp;r;r=r->ptr.tp) EnQueue(Q,r);
  }//while
}//GList_PrintElem_LOrder

分析:层序遍历的问题,一般都是借助队列来完成的,每次从队头取出一个元素的同时把它下一层的孩子插入队尾.这是层序遍历的基本思想.

  

Beta3
关注
专栏目录
数组和广义表
任杰的博客
03-23 563
一、数组 数组是一组类型相同的数据元素构成。有一维数组、二维数组、n维数组。一般实现时，可以重载操作符，比较方便一点。   二、矩阵 1、矩阵的加减，需要两个矩阵拥有相同的行列数才可以。对应各个位置分别进行计算 2、矩阵的相乘，需要第一个阵的列数等于第二个的行数。如C(0,0)=A的第一列分别乘以B的第一行相加的结果。 3、特殊矩阵        三对角矩阵、三角矩阵（上三角、下三角
数组广义表
07-13
#include<iostream> #include<string.h> #include<stdlib.h> #define MaxSize 100 typedef int st[MaxSize][3]; void creat(int A[4][7],st B)//构造三元组 { int i,j,k=1; for (i=0;i<4;i++) for(j=0;j<7;j++) if(A[i][j]!=0) { B[k][0]=i; B[k][1]=j; B[k][2]=A[i][j]; k++; } B[0][0]=4;B[0][1]=7; B[0][2]=k-1; }
数据结构第五章：数组与广义表
read, note and comment papers
08-30 128
数据结构第五章：数组与广义表 稀疏矩阵指非零元占矩阵元素总数比例小于5%的一类矩阵，可以用三元组表表示，用某种方法来组织稀疏矩阵的三元组表的存储就可以实现矩阵的压缩存储 三元组顺序表 用顺序表表示稀疏矩阵三元组，如下： struct Triple{ int i,j;//行索引，列索引 ElemType e; } struct TSMatrix{ Triple data[MAXSIZE + 1]; int mu, nu, tu;//行数，列数，非零元个数 } 需要约定三元组在顺序表中的排列
数据结构 第五章 数组和广义表
哆啦A梦~~
05-01 279
注：下三角矩阵中：i&lt;j 时 k=n(n+1)/2,是因为上三角中的元素是同一个值，所以就存在矩阵的最后一个位置即可。        上三角矩阵同理。
数据结构练习（含答案）：第五章数组和广义表.doc
09-20
数据结构练习（含答案）：第五章数组和广义表 本资源摘要信息涵盖了数据结构中数组和广义表的相关知识点，包括数组的基本操作、数组的存储方式、稀疏矩阵的压缩存储方法、对称矩阵的存储方式等。 一、选择题 1. ...
第5章数组和广义表.ppt
11-28
数组和广义表 本章节主要介绍数组和广义表的概念、定义、存储结构和实现算法。数组是由多个相同类型的数据元素组成的有限序列，存储在一块地址连续的内存单元中。数组可以是一维、二维、三维甚至高维数组，每个维度...
第五章 数组和广义表.ppt
12-05
在本章中，我们将深入探讨数组和广义表的概念。 首先，我们来了解一下数组的类型定义。数组（Array）可以看作是同类型元素的有序集合，这些元素可以通过一个或多个下标来访问。在数据结构的抽象数据类型（ADT）表示...
数据结构课程中的第五章 数组和广义表PPT
03-26
南航数据结构课程中的第五章 数组和广义表PPT。
第5章 数组和广义表.pptx
最新发布
04-10
### 数组和广义表知识点概述 #### 一、数组的概念与分类 1. **数组定义**： - 数组可以被理解为一种特殊的线性表形式，其中数据元素自身也可能是一个线性表。 - **一维数组**：简单来说，就是一系列线性排列的...
递归逆转广义表
05-31
递归逆转广义表————————
数组与广义表
fighting123678的博客
12-23 423
一、数组 数组的定义 1、数组是一组有固定个数的数据元素的集合，这使得对数组的操作不再像线性表那样可以在表中任意合法的位置上插入或删除一个元素。 2、对数组的操作一般只有两类：获取或修改特定位置元素的值。广义表、普通数组的各项操作都不会引起元素的插入或删除，因此，数组可看作普通线性表的推广,数组常采用顺序存储结构。 数组的顺序表示和实现 （一）类型特点 1、数组是多维的结构，而存储空间是一个一维...
《数组和广义表》
qq_28409093的博客
04-09 484
1、什么是广义表？ 广义表是线性表的推广，也称为列表，线性表的元素仅限于原子，即从结构上不可再分，广义表的元素不仅限于原子，也可以是广义表 2、广义表的长度？ 最外层包含元素的个数。如何计算？用替换思想。空表的长度为0. 例如LS = （（））长度为1 LS = (A)； 3、广义表的深度？ 定义为包括弧的重度。 4、表头表尾？ 任意一非空的广义表，都可以分为表头表尾。一个元素不是表头就是表尾。 确定表头表尾可唯一确定一个广义表 5、广义表的基本元素？ 表头表尾，长度，深度 S = （a,
数据结构——数组、广义表
m0_56046092的博客
08-18 260
数组 特点 数组的特点：结构固定，定义后维数和维界不变。数组可以是多维，但存储空间是一维的，所以重点在解决映射关系。注意数组中元素位置的计算。 三维数组按页优先的顺序存储 特殊矩阵的压缩存储 1.对称矩阵压缩为只用存储下/下三角（包括对角线元素） 个元素←→ n(n+1)/2元素 a[i][j] ←→ b[k]数组下标0开始 2.三角矩阵的压缩 n²个元素←→ n(n+1)/2+1元素,常数c共享一个元素存储空间故+1 3.对角矩阵的压缩存储 当b＝1时称为三对角矩阵。其压缩地址计算公式如下：k=2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值