已经学过的线性表：数据元素都是非结构的原子类型。

数组和广义表的特点：一种特殊的线性表

① 元素的值并非原子类型，可以再分解，表中元素也是一个线性表（即广义的线性表）。即数据元素本身也是一个数据结构。

② 所有数据元素仍属同一数据类型。

数组的定义

数组： 由一组名字相同、下标不同的变量构成。

一维数组的特点：1个下标，ai 是ai+1的直接前驱

二维数组的特点：2个下标，每个元素ai,j受到两个关系（行关系和列关系）的约束：

一个m×n的二维数组可以看成是m行的一维数组，或者n列的一维数组。

N维数组的特点：n个下标，每个元素受到n个关系约束。

一个n维数组可以看成是由若干个n－1维数组组成的线性表。

N维数组的数据类型定义

n_ARRAY = (D, R)

其中：数据对象：

数据关系：

基本操作：构造数组、销毁数组、读数组元素、写数组元素

数组的顺序表示和实现

问题：计算机的存储结构是一维的，而数组一般是多维的，怎样存放？

解决办法：事先约定按某种次序将数组元素排成一列序列，然后将这个线性序列存入存储器中。

例如：在二维数组中，我们既可以规定按行存储，也可以规定按列存储。

注意： 若规定好了次序，则数组中任意一个元素的存放地址便有规律可寻，可形成地址计算公式；

约定的次序不同，则计算元素地址的公式也有所不同；

C和PASCAL中一般采用行优先顺序；FORTRAN采用列优先。

行优先顺序推广到多维数组，可规定为先排最右的下标。

按行优先存储的寻址

二维数组，第一维的长度是b1，第二维的长度是b2.LOC(aij)=LOC(a00)+(i×b2+j) ×L

无论规定行优先或列优先，只要知道以下三要素便可随时求出任一元素的地址（这样数组中的任一元素便可以随机存取！）：

①开始结点的存放地址（即基地址） ②维数和每维的上、下界； ③每个数组元素所占用的单元数

补充：计算二维数组元素地址的通式 设一般的二维数组是A[c1..d1, c2..d2]，这里c1,c2不一定是0。

则行优先存储时的地址公式为：

二维数组列优先存储的通式为：

顺序存储方式：按低地址优先（或高地址优先）顺序存入一维数组。（难点是多维数组与一维数组的地址映射关系）

该式称为n维数组的映像函数：

N维数组的顺序存储表示

#define MAX_ARRAY_DIM   8   //假设最大维数为8
 typedef struct{
      ELemType *base;       //数组元素基址
      int            dim;             //数组维数
      int          *bound;        //数组各维长度信息保存区基址
      int         *constants;   //数组映像函数常量的基址，即Ci信息保存区，C1到Cn

   }Array;，

< stdarg.h > ：利用函数va_start、va_arg和va_end提供遍历未知数目和类型的函数参数表的功能。

Va_start ( va_list  ap,  x )：初始化ap，使其指向所在函数的参数x之后的第一个参数。

Va_arg ( va_list  ap ,  类型)：返回ap当前指向的参数的值，并修改ap，使得ap指向下一个参数（“类型”为参数类型）。

Va_end ( va_list  ap)：用在所有的参数处理完毕之后，表示ap使用完毕。

数组的基本操作函数说明（5个）

Status InitArray (Array &A, int dim,…){    
//若维数dim和各维长度合法，则构造相应的数组A并返回OK
   if (dim<1||dim>MAX_ARRAY_DIM)  return ERROR;
   A.dim=dim;
   A.bounds=(int *)malloc(dim * sizeof(int)); 
    if(!a.bounds) exit(OVERFLOW); // 分配存放“各维长度”的空间
 //若各维长度合法，则存入A.bounds,并求出A的元素总数elemtotal
  elemtotal=1;
   va_start(ap, dim); 
           //ap为va_list类型，是存放变长参数表信息的   类型，将ap指向dim后的第一个参数
   for(i=0;i<dim;++i) {
       A.bounds[i]=va_arg (ap, int);   
              // 返回ap当前指向的参数，并按参数类型将ap指向下一个参数
       if (A.bounds[i]<0) return UNDERFLOW;
       elemtotal *=A.bounds[i];   }
    va_end(ap);     //  ap使用完毕
   A.base=(ElemType * )malloc(elemtotal * sizeof(ElemType));
   if(!A.base) exit(OVERFLOW);  //  分配数组元素空间
   A.constants=(int * )malloc(dim *sizeof(int));
   if(!A.constans) exit(OVERFLOW);    //分配存放C i的空间
   A.constans[dim-1]=1;   //  L=1 
   for(i=dim-2;i>=0;--i)
      A.constants[i]=A.bounds[i+1]*A.constants[i+1];// b i+1    C i+1
   return OK;                 
 }

Status DestroyArray (Array &A)
{     //销毁数组A
   if ( ! A.base )  return   ERROR;
   free(A.base);//数组基址指针
   A .base  =  NULL;
   if ( ! A.bounds )  return ERROR;
   free( A .bounds );//各维长度保存区指针
   A.bounds = NULL;
   if ( !A.constants )   return ERROR;
   free ( A. constants ) ;//映像函数Ci保存区指针
   A. constants = NULL;
   return OK;
 }

Status Locate(Array A, va_list ap, int &off) {
//若ap指示的各下标值合法，则求出该元素在A中相对地址off
    off=0;
    for(i=0;i<A.dim;++i)
    {
      ind= va_arg(ap, int);
      if (ind<0||ind>A.bounds[i]) return OVERFLOW;
      off += A.constants[i]  * ind ;//C i * j i
    }                     
    return OK;
 }

Status Value(Array A, ElemType &e,…)
{
  //A是n维数组，e为元素变量，随后是n个下标值，若各下标不超界，则e赋值为所指定的A的元素值，即将指定元素值读到e变量中。
   va_start (ap, e);  // 将ap指向e后的参数
   if((result=Locate(A, ap, off))<=0) return result;
   e=*(A.base+off); 
   return OK;
 }

Status Assign(Array &A,ElemType e,…)
{
  //A是n维数组，e为元素变量，随后是n个下标值，若各下 标不超界，则e的值赋为所指定的A的元素值，即：将e值写入指定数组单元。
   va_start(ap,e);
   if( (result=Locate(A,ap,off ) )<=0) return result;
   *(A.base+off)=e;
   return OK;
 }

矩阵的压缩存储(即数组的应用)

1. 什么是压缩存储？

若多个数据元素的值都相同，则只分配一个元素值的存储空间，且零元素不占存储空间。

2. 什么样的矩阵具备压缩条件？      

特殊矩阵（对称矩阵，对角矩阵，三角矩阵） 和稀疏矩阵。

3. 什么叫稀疏矩阵？

矩阵中非零元素的个数较少（一般小于5%）

特殊矩阵的压缩存储—对称矩阵  对称矩阵特点：aij=aji

如何压缩存储？只存储下三角部分的元素。以一维数组sa[n(n+1)/2]作为存储结构。

1+2+…+n=n(n+1)/2

sa[k]和aij间的对应关系(1=<i,j<=n)

当i>=j时，aij是下三角中的元，k=i(i-1)/2+j-1

当i<j时， aij是上三角中的元， k=j(j-1)/2+i-1

aij的i和j是从1开始

sa[k]的k是从0开始

问题： 如果只存储稀疏矩阵中的非零元素，那这些元素的位置信息该如何表示？

解决思路： 对每个非零元素增开若干存储单元，例如存放其所在的行号和列号，便可准确反映该元素所在位置。

实现方法： 将每个非零元素用一个三元组（i，j，aij）来表示，则每个稀疏矩阵可用一个三元组表来表示。

用三元组表表示

注意：为更可靠描述，通常再加一行“总体”信息：即总行数、总列数、非零元素总个数

稀疏矩阵压缩存储的缺点：将失去随机存取功能

用十字链表表示

当矩阵的非0元素个数和位置在操作中变化较大时，适合用十字链表。

用途：方便稀疏矩阵的加减运算；例如插入一个非0元素或者删除一个非0元素。

方法：每个非0元素占用5个域。

十字链表的特点：

①每行非零元素链接成带表头结点的链表；

②每列非零元素也链接成带表头结点的链表。 则每个非零元素既是行、链表中的一个结点；又是列循环链表中的一个结点，即呈十字链状。

三元组表的顺序存储表示

 #define MAXSIZE 125000  //设非零元素最大个数125000
 typedef struct  {
   int i;             //元素行号
   int j;            //元素列号
   ElemType e;     //元素值
} Triple;        //一个结点的结构定义

typedef struct  {
 Triple  data[MAXSIZE+1]; 
//三元组表，以行为主序存入一维向量 data[ ]中
    int mu;       //矩阵总行数
    int nu;       //矩阵总列数
    int tu;       //矩阵中非零元素总个数
} TsMatrix;     //整个三元组表的定义

稀疏矩阵的操作（以转置运算为例）

采用三元组压缩技术存储稀疏矩阵

（1）每个元素的行下标和列下标互换（即三元组中的i和j互换）；

（2）T的总行数mu和总列数nu与M的不同（互换）；        

（3）重排三元组内元素顺序，使转置后的三元组也按行（或列）为主序有规律的排列。

（1）和（2）容易实现，难点在（3）。有两种实现方法：压缩转置、(压缩)快速转置

压缩转置

思路：反复扫描a.data中的列序，从小到大依次进行转置。

压缩转置算法描述：

Status TransPoseSMatrix(TSMatrix M, TSMatrix &T)
{    //用三元组表存放稀疏矩阵M，求M的转置矩阵T
T.mu=M.nu;  T.nu=M.mu;  T.tu=M.tu;
 if (T.tu) { 
   q=1;          //q是转置矩阵T的结点编号
   for(col=1; col<=M.nu; col++) //col是扫描M三元表列序的变量
     {for(p=1; p<=M.tu; p++) //p是M三元表中结点编号
        {if (M.data[p].j==col)
            {T.data[q].i=M.data[p].j;  T.data[q].j=M.data[p].i;
                T.data[q].value=M.data[p].value;  q++;
            }
          }
      }
   }
     return OK;
} //TranposeSMatrix;

压缩转置算法的效率分析：

主要时间消耗在查找M.data[p].j=col的元素，由两重循环完成:  for(col=1; col<=M.nu; col++)  循环次数＝nu ，for(p=1; p<=M.tu; p++)    循环次数＝tu 所以该算法的时间复杂度为O(nu*tu)         —-即M的列数与M中非零元素的个数之积

最恶劣情况：M中全是非零元素，此时tu=mu*nu，时间复杂度为 O(nu2*mu )

注：若M中基本上是非零元素时，即使用非压缩传统转置算法的时间复杂度也不过是O(nu*mu) 

结论：压缩转置算法不能滥用。

前提：仅适用于非零元素个数很少（即tu<<mu*nu）的情况。

快速转置

思路：依次把a.data中的元素直接送入b.data的恰当位置上（即M三元组的p指针不回溯）。

设计思路：如果能预知M矩阵每一列(即T的每一行)的非零元素个数，又能预知第一个非零元素在b.data中的位置,则扫描a.data时便可以将每个元素准确定位（因为已知若干参考点）。请注意a.data特征：每列首个非零元素必定先被扫描到。

技巧：利用带辅助向量的三元组表，它正好携带每行（或列）的非零元素个数 NUM(i)以及每行（或列）的第一个非零元素在三元组表中的位置POS(i) 等信息。

令：M中的列变量用col表示；

num[ col ]：存放M中第col 列中非0元素个数

cpot[ col ]：存放M中第col列的第一个非0元素的位置，（即b.data中待计算的“恰当”位置所需参考点）

按列优先的辅助向量求出后， 由a.data中每个元素的列信息，即可直接查出b.data中的重要参考点之位置，进而可确定当前元素之位置！

快速转置算法描述：

Status FastTransposeSMatrix（TSMatirx M, TSMatirx &T）
{           //M用顺序存储表示，求M的转置矩阵T
T.mu = M.nu ;T .nu = M.mu ; T.tu = M.tu ;
 if ( T.tu ) {
for(col = 1; col <=M.nu; col++) num[col] =0;  //初始化M中各列元素个数为0
for( i = 1; i <=M.tu; i ++) {col =M.data[ i ] .j ; ++num [col] ;}
 cpot[ 1 ] =1;    //再生成每列首元位置辅助向量表
 for(col = 2; col <=M.nu; col++)  cpot[col ]=cpot[col-1]+num [col-1 ] ;
 for( p =1; p <=M.tu ; p ++ )    //p指向a.data，循环次数为非0元素总个数tu
  { col =M.data[ p ]. j ; q =cpot [ col ];     //查辅助向量表得q，即T中位置
                    T.data[q].i = M.data[p]. j;
                    T.data[q].j = M.data[p]. i;
                    T.data[q]. value = M.data[p]. value;
                    + + cpot[col] ;//重要语句！修改向量表中列坐标值，供同一列下一非零元素定位之用！
   }  //for
}  //if
return OK; 
}  //FastTranposeSMatrix;

快速转置算法的效率分析：

1. 与常规算法相比，附加了生成辅助向量表的工作。增开了2个长度为列长的数组(num[ ]和cpos[ ]）。

2. 从时间上，此算法用了4个并列的单循环，而且其中前3个单循环都是用来产生辅助向量表的。

         for(col = 1; col <=M.nu; col++)  循环次数＝nu;

         for( i = 1; i <=M.tu; i ++)            循环次数＝tu;

         for(col = 2; col <=M.nu; col++)  循环次数＝nu;

         for( p =1; p <=M.tu ; p ++ )       循环次数＝tu;

该算法的时间复杂度＝(nu*2)+(tu*2)=O(nu+tu）

最恶劣情况是tu=nu*mu(即矩阵中全部是非零元素）， 而此时的时间复杂度也只是O(mu*nu)，并未超过传统转置算法的时间复杂度。

传统转置：O(mu*nu)    压缩转置：O(mu*tu)     压缩快速转置：O(nu+tu)——牺牲空间效率换时间效率。

广义表的定义

广义表是线性表的推广，也称为列表（lists）。记为：

在广义表中约定：① 第一个元素是表头，而其余元素组成的表称为表尾； ② 用小写字母表示原子类型，用大写字母表示列表。

广义表中元素既可以是原子类型，也可以是列表； 当每个元素都为原子且类型相同时，就是线性表。

D=(A,B,C)=(( ),(e),(a,(b,c,d)))，共享表

E=(a,E)=(a,(a,E))= (a,(a,(a,…….)))，E为递归表

特点：

有次序性：一个直接前驱和一个直接后继

有长度：＝表中元素个数

有深度：＝表中括号的重数

可递归：自己可以作为自己的子表

可共享：可以为其他广义表所共享

①的长度为3，深度为3                                                ②的长度为2，深度为∞

深度＝括号的重数＝    结点的层数

两种特殊的基本操作： GetHead( L) ——取表头(可能是原子或列表); GetTail(L )   ——取表尾(一定是列表) 。

特别提示：任何一个非空表，表头可能是原子，也可能是列表；但表尾一定是列表。

广义表的存储结构

由于广义表中的数据元素的类型不统一，因此难以采用顺序存储结构来存储。

若广义表不空，则可分解为表头和表尾；反之，一对确定的表头和表尾可唯一地确定一个广义表。

采用头尾表示法存储广义表

广义表的存储结构——头尾表示法

广义表中的数据元素既可以是广义表也可以是单元素，  表结点——存储广义表；原子结点——存储单元素

结点结构

tag：区分表结点和元素结点的标志； hp：指向表头结点的指针； tp：指向表尾结点的指针； data：数据域，存放单元素。

另外一种存储方法：

1.原子结点

2.表结点    

代码实现：矩阵的两种转置运算https://blog.csdn.net/qq1457346557/article/details/107122911