数据结构个人笔记 第12课 数组

数组

一说起数组，我们的印象中数组往往是某一门编程语言中包含的具体数据类型，其实不然。
本节所讲的数组，要将其视为一种存储结构，与平时使用的数组基本数据类型区分开

从本质上讲，数组与顺秀表、链表、栈和队列一样，都用来存储具有“一对一”逻辑关系数据的线性存储结构。
不仅如此，数组和其他线性存储结构不同，顺序表、链表、栈和队列存储的都是不可再分的数据元素，而数组既可以用来存储不可再分的数据元素，也可以用来存储像顺序表、链表这样的数据结构。

比如说，数组可以直接存储多个顺序表。我们知道，顺序表的底层实现还是数组，因此与平时使用的二维数组类似

注意：无论数组的维数是多少，数组中的数据类型都必须保持一致
一维数组结构是线性表的基本表现形式，而n维数组可理解为是对线性存储结构的一种扩展。

数组的顺序存储

数组作为一种线性存储结构，对存储的数据通常只做查找和修改操作，因此数据结构是实现使用的是顺序存储结构（要知道，对数组中存储的数据做插入和删除操作，算法的效率是很差的）

由于数组可以是多维的，而顺序存储结构是一维的，因此数组中数据的存储要制定一个先后次序。通常，数组中数据的存储有两种先后存储方式：

1. 以列序为主（先列后行）：按照行号从小到大的顺序，依次存储每一列的元素
2. 以行序为主（先行后列）：按照列号从小到大的顺序，依次存储每一行的元素

多维数组中，我们最常用的是二维数组。比如：当二维数组a[6] [6]按照列序为主的次序顺序存储时，数组在内存中的存储状态如图所示：

而当以行序为主时：

在c语言中，多维数组的存储采用的是以行序为主的顺序存储方式

多维数组查找指定元素

当需要在顺序存储的多维数组中查找某个指定元素时，需知道以下信息：

1. 多维数组的存储方式
2. 多维数组在内存中存放的起始地址
3. 该指定元素在原多维数组的坐标
4. 数组中数组的具体类型，即数组中单个数组元素所占用的内存的大小，通常用字母L表示

根据存储方式的不同，查找目标元素的方式也不同，如果二维数组采用以行序为主的方式，则再二维数组anm中查找aij存放位置的公式为：

LOC(i,j) = LOC(0,0) + (i*m + j)*L;

其中，LOC(i,j)为aij在内存中的地址，LOC（0,0）为二维数组在内存中存放的起始位置（也就是a00的位置）

如果采用以列存储的方式，则公式为：

LOC(i,j) = LOC(0,0) + (i*n + j) *L;

示范代码

#include
#include
#include
#include // atoi()
#include // eof()
#include

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW 3
#define UNDERFLOW 4
typedef int Status; //Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; //Boolean是布尔类型,其值是TRUE或FALSE
typedef int ElemType;

#define MAX_ARRAY_DIM 8 //假设数组维数的最大值为8
typedef struct
{
    ElemType *base; //数组元素基址，由InitArray分配
    int dim; //数组维数
    int *bounds; //数组维界基址，由InitArray分配
    int *constants; // 数组映象函数常量基址，由InitArray分配
} Array;

Status InitArray(Array *A,int dim,...)
{
    //若维数dim和各维长度合法，则构造相应的数组A，并返回OK
    int elemtotal=1,i; // elemtotal是元素总值
    va_list ap;
    if(dim<1||dim>MAX_ARRAY_DIM)
        return ERROR;
    (*A).dim=dim;
    (*A).bounds=(int *)malloc(dim*sizeof(int));
    if(!(*A).bounds)
        exit(OVERFLOW);
    va_start(ap,dim);
    for(i=0; i<dim; ++i)
    {
        (*A).bounds[i]=va_arg(ap,int);
        if((*A).bounds[i]<0)
            return UNDERFLOW;
        elemtotal*=(*A).bounds[i];
    }
    va_end(ap);
    (*A).base=(ElemType *)malloc(elemtotal*sizeof(ElemType));
    if(!(*A).base)
        exit(OVERFLOW);
    (*A).constants=(int *)malloc(dim*sizeof(int));
    if(!(*A).constants)
        exit(OVERFLOW);
    (*A).constants[dim-1]=1;
    for(i=dim-2; i>=0; --i)
        (*A).constants[i]=(*A).bounds[i+1]*(*A).constants[i+1];
    return OK;
}
Status DestroyArray(Array *A)
{
    //销毁数组A
    if((*A).base)
    {
        free((*A).base);
        (*A).base=NULL;
    }
    else
        return ERROR;
    if((*A).bounds)
    {
        free((*A).bounds);
        (*A).bounds=NULL;
    }
    else
        return ERROR;
    if((*A).constants)
    {
        free((*A).constants);
        (*A).constants=NULL;
    }
    else
        return ERROR;
    return OK;
}
Status Locate(Array A,va_list ap,int *off) // Value()、Assign()调用此函数 */
{
    //若ap指示的各下标值合法，则求出该元素在A中的相对地址off
    int i,ind;
    *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;
    }
    return OK;
}
Status Value(ElemType *e,Array A,...) //在VC++中，...之前的形参不能是引用类型
{
    //依次为各维的下标值，若各下标合法，则e被赋值为A的相应的元素值
    va_list ap;
    Status result;
    int off;
    va_start(ap,A);
    if((result=Locate(A,ap,&off))==OVERFLOW) //调用Locate()
        return result;
    *e=*(A.base+off);
    return OK;
}
Status Assign(Array *A,ElemType e,...)
{
    //依次为各维的下标值，若各下标合法，则将e的值赋给A的指定的元素
    va_list ap;
    Status result;
    int off;
    va_start(ap,e);
    if((result=Locate(*A,ap,&off))==OVERFLOW) //调用Locate()
        return result;
    *((*A).base+off)=e;
    return OK;
}

int main()
{
    Array A;
    int i,j,k,*p,dim=3,bound1=3,bound2=4,bound3=2; //a[3][4][2]数组
    ElemType e,*p1;
    InitArray(&A,dim,bound1,bound2,bound3); //构造3＊4＊2的3维数组A
    p=A.bounds;
    printf("A.bounds=");
    for(i=0; i<dim; i++) //顺序输出A.bounds
        printf("%d ",*(p+i));
    p=A.constants;
    printf("\nA.constants=");
    for(i=0; i<dim; i++) //顺序输出A.constants
        printf("%d ",*(p+i));
    printf("\n%d页%d行%d列矩阵元素如下:\n",bound1,bound2,bound3);
    for(i=0; i<bound1; i++)
    {
        for(j=0; j<bound2; j++)
        {
            for(k=0; k<bound3; k++)
            {
                Assign(&A,i*100+j*10+k,i,j,k); // 将i*100+j*10+k赋值给A[i][j][k]
                Value(&e,A,i,j,k); //将A[i][j][k]的值赋给e
                printf("A[%d][%d][%d]=%2d ",i,j,k,e); //输出A[i][j][k]
            }
            printf("\n");
        }
        printf("\n");
    }
    p1=A.base;
    printf("A.base=\n");
    for(i=0; i<bound1*bound2*bound3; i++) //顺序输出A.base
    {
        printf("%4d",*(p1+i));
        if(i%(bound2*bound3)==bound2*bound3-1)
            printf("\n");
    }
    DestroyArray(&A);
    return 0;
}

矩阵（稀疏矩阵）压缩存储（三种方式）

数据结构中，提供针对某些特殊矩阵的压缩存储结构

这里所说的特殊矩阵，主要分为以下两类：

• 含有大量相同数据元素的矩阵，比如对称矩阵
• 含有大量0元素的矩阵，比如稀疏矩阵、上（下）三角矩阵

针对以上两类矩阵，数据结构的压缩存储思想是：矩阵中的相同数据元素（包括元素0）只存储一个

对称矩阵

在图中的矩阵中，数据远古三沿着主对角线对应相等，这类矩阵称为对称矩阵
矩阵中有两条对角线，其中图中的对角线称为主对角线，另一条从左下角到右上角的对角线为副对角线。对称矩阵指的是各数据元素沿主对角线对称的矩阵

结合数据结构压缩存储的思想，我们可以使用以为数组存储对称矩阵。由于矩阵中沿对角线两侧的数据相等，因此数组中只需存储对角线一侧（包含对角线）的数据即可

对称矩阵的实现过程是，若存储下三角中的元素，只需将各元素所在的行标i和列表j带入下面的公式

k = (i*(i-1))/2+j-1

存储上三角的元素要将各元素的行标i和列标j带入另一个公式：

k = (j * (j-1))/2 +i -1

最终求得的k值即为该元素存储到数组中的位置（矩阵中元素的行标和列标都从1开始）

上（下）三角矩阵

主对角线下的数据元素全部相同的矩阵为上三角矩阵，主对角线上元素全部相同的矩阵为下三角矩阵

对于这种特殊的矩阵，压缩存储的方式是：上（下）三角矩阵采用对称矩阵的方式存储上（下）三角的数据（元素0不用存储）

稀疏矩阵

如果矩阵中分布有大量的元素0，即非0元素非常少，这类矩阵称为稀疏矩阵

压缩存储稀疏矩阵的方法是：只存储矩阵中的非0元素，与前面的存储方法不同，稀疏矩阵非0元素的存储需同时存储该元素所在矩阵中的行标和列表

对于稀疏矩阵的压缩存储，数据结构提供有3种具体的实现方式：

1. 三元组顺序表
2. 行逻辑连接的顺序表
3. 十字链表

将在下次的笔记中更新