数组的基本操作

数组的顺序存储表示和实现

#include<stdarg.h>
#define MAX_ARRAY_DIM 8
#define ElemType int
typedef struct
{
    ElemType *base;         //数组元素的基址,由InitArray分配
    int dim;                 //数组维数
    int *bounds;             //数组维界基址,由InitArray分配
    int *constants;           //数组映像函数常量基址，由InitArray分配
}Array;

InitArray(&A,n,bound1,…,boundn)

初始条件：无
操作结果：若维数n和各维长度合法，则构造相应的数组A,并返回OK
代码：

int InitArray(Array *A,int dim,...)
{//若维数dim和各维长度均合法，则构造相应的数组A，并返回1.
    int elemtotal=1;
    int i;
    va_list ap;
    if (dim<0 || dim > MAX_ARRAY_DIM)
        return 0;
    A->dim = dim;

    A->bounds = (int *)malloc(dim*sizeof(int));
    if (!A->bounds) return 0;
    va_start(ap,dim);

    for (i=0;i<dim;++i)
    {
        A->bounds[i] = va_arg(ap,int);
        if (A->bounds[i]<0) return 0;
        elemtotal *= A->bounds[i];
    }


    va_end(ap);
    A->base = (ElemType *)malloc(elemtotal*sizeof(ElemType));
    if (!A->base) return 0;
    A->constants = (int *)malloc(dim*sizeof(int));
    A->constants[dim-1] = 1;
    for (i=dim-2;i>=0;--i)
    {
        A->constants[i] = A->bounds[i+1] * A->constants[i+1];
    }
    return 1;

}

DestroyArray(&A)

初始条件：无
操作结果：销毁数组A
代码：

int DestroyArray(Array *A)  //销毁数组A
{
    if (!A->base) return 0;
    free(A->base);
    A->base = NULL;

    if (!A->bounds) return 0;
    free(A->bounds);
    A->bounds = NULL;

    if (!A->constants) return 0;
    free(A->constants);
    A->constants = NULL;
    return 1;
}

Value(A,&e,index1,…,indexn)

初始条件：无
操作结果：若各下标不越界，则e赋值为所指定的A的元素值，并返回OK
代码：

int Value(Array *A,ElemType *e,...)
{//A是n维数组,e为元素变量，随后是n个下标值
    //若下标都合法，则e赋值为指定的A的元素值，并返回1
    va_list ap;
    va_start(ap,e);
    int off;
    int result;
    if ((result=Locate(A,ap,&off))<=0) return result;
    *e = *(A->base+off);
    return 1;
}

Assign(&A,e,index1,…indexn)

初始条件：
操作结果：若下标不越界，则e的值赋给所指定的A的元素，并返回OK
代码：

int Assign(Array *A,ElemType e,...)
{//A是n维数组,e为元素变量,随后是n个下标值.
    //若下标均合法，则将e的值赋给所指定的A的元素，并返回1
    va_list ap;
    va_start(ap,e);
    int off;
    int result;
    if ((result=Locate(A,ap,&off))<=0) return result;
    *(A->base+off) = e;
    return 1;


}

其中的Locate函数代码：

int Locate(Array *A,va_list ap,int *off)
{//若ap指示的各下标均合法，则求出该元素在A中的相对地址off
    *off = 0;
    int ind;
    for (int i=0;i<A->dim;++i)
    {
        ind = va_arg(ap,int);

        if (ind < 0 || ind >= A->bounds[i]) return 0;
        *off += A->constants[i] * ind;

    }
    return 1;
}

使用：

#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
#define MAX_ARRAY_DIM 8
#define ElemType int
typedef struct
{
    ElemType *base;         //数组元素的基址,由InitArray分配
    int dim;                 //数组维数
    int *bounds;             //数组维界基址,由InitArray分配
    int *constants;           //数组映像函数常量基址，由InitArray分配
}Array;

int InitArray(Array *A,int dim,...)
{//若维数dim和各维长度均合法，则构造相应的数组A，并返回1.
    int elemtotal=1;
    int i;
    va_list ap;
    if (dim<0 || dim > MAX_ARRAY_DIM)
        return 0;
    A->dim = dim;

    A->bounds = (int *)malloc(dim*sizeof(int));
    if (!A->bounds) return 0;
    va_start(ap,dim);

    for (i=0;i<dim;++i)
    {
        A->bounds[i] = va_arg(ap,int);
        if (A->bounds[i]<0) return 0;
        elemtotal *= A->bounds[i];
    }


    va_end(ap);
    A->base = (ElemType *)malloc(elemtotal*sizeof(ElemType));
    if (!A->base) return 0;
    A->constants = (int *)malloc(dim*sizeof(int));
    A->constants[dim-1] = 1;
    for (i=dim-2;i>=0;--i)
    {
        A->constants[i] = A->bounds[i+1] * A->constants[i+1];
    }
    return 1;

}
int DestroyArray(Array *A)  //销毁数组A
{
    if (!A->base) return 0;
    free(A->base);
    A->base = NULL;

    if (!A->bounds) return 0;
    free(A->bounds);
    A->bounds = NULL;

    if (!A->constants) return 0;
    free(A->constants);
    A->constants = NULL;
    return 1;
}

int Locate(Array *A,va_list ap,int *off)
{//若ap指示的各下标均合法，则求出该元素在A中的相对地址off
    *off = 0;
    int ind;
    for (int i=0;i<A->dim;++i)
    {
        ind = va_arg(ap,int);

        if (ind < 0 || ind >= A->bounds[i]) return 0;
        *off += A->constants[i] * ind;

    }
    return 1;
}
int Value(Array *A,ElemType *e,...)
{//A是n维数组,e为元素变量，随后是n个下标值
    //若下标都合法，则e赋值为指定的A的元素值，并返回1
    va_list ap;
    va_start(ap,e);
    int off;
    int result;
    if ((result=Locate(A,ap,&off))<=0) return result;
    *e = *(A->base+off);
    return 1;
}
int Assign(Array *A,ElemType e,...)
{//A是n维数组,e为元素变量,随后是n个下标值.
    //若下标均合法，则将e的值赋给所指定的A的元素，并返回1
    va_list ap;
    va_start(ap,e);
    int off;
    int result;
    if ((result=Locate(A,ap,&off))<=0) return result;
    *(A->base+off) = e;
    return 1;


}


int main()
{
    Array A;
    ElemType e=1999;
    ElemType te;
    InitArray(&A,3,2,2,3); //构造一个三维的数组,可以形象的理解为a[2][2][3](数组名随便写的);
    printf("e = %d\n",e);

    Assign(&A,e,1,1,1);   //将e存入对应的数组元素
    Value(&A,&te,1,1,1);  //取出对应的数组元素到te中

    printf("te = %d\n",te);


    return 0;
}

运行结果：