【Data】数组的顺序表示与实现

一、数组的定义

几乎所有的程序设计语言都把数组类型设定为固有类型。

以抽象数据类型的形式讨论数组的定义和实现，可以让我们加深对数组类型的理解。

数组的定义：

ADT Array{

数据对象:ji=0,...,bi-1,i=1,2,...,n;

D={aj1j2...jn|n(>0)称为数组的维数,bi是数组第i维的长度,ji是数组元素的第i维下标,aj1j2...jn (-ElemSet}

数据关系:R={R1,R2,...Rn|

Ri={<aj1...ji...jn,aj1...ji+1 ...jn>|

0<=jk<=bk-1,1<=k<=n且k<>i,

0<=ji<=bi-2,aj1...ji...jn,

aj1...ji+1 ...jn(-D,i=2,...n}

基本操作:

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

若维数和各维长度合法,则构造相应的数组A,并返回OK.

DestroyArray(&A)

操作结果:销毁数组A.

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

初始条件:A是n维数组,e为元素变量,随后是n个下标值.

操作结果:若各下标不超界,则e赋值为所指定的A的元素值,并返回OK.

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

初始条件:A是n维数组,e为元素变量,随后是n个下标值.

操作结果:若下标不超界,则将e的值赋给 所指定的A的元素,并返回OK.

}ADT Array

（本来我觉得数组这块儿没什么难的，还挺容易理解的，非要整什么抽象模板，一下就抽象了）

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#define  MAX_ARRAY_DIM 8

typedef struct {
    int  dim;           // 维数, 比如2维数组, 3维数组
    int *base;        // 数组的基地址, 任一维的形式在内存中都作为一维存储, 线性排列
    int *bounds;    // 数组维界基址, 记录每维大小
    int *constants;// 数组映象函数常量基址, 用于定位元素使用
}array_st;

int elem_total;     // 计算元素总个数, 申请连续内存

int init_array(array_st *array, int dim, ...)
{
    int i;
    va_list ap;//变长参数，在stdarg.h中

    if(dim < 1 || dim > MAX_ARRAY_DIM)
        return -1;

    array->dim = dim;
    array->bounds = (int *)malloc(dim * sizeof(int));
    if(!array->bounds)
        return -1;

    elem_total = 1;
    va_start(ap, dim);//意思大概是ap这个变长参数的地址从dim后面开始
    for(i = 0; i < dim; i++) {
        array->bounds[i] = va_arg(ap, int);//逐一为bounds[i]赋值
        if(array->bounds[i] < 0)
            return -1;
        elem_total *= array->bounds[i]; // n维数组, 每维数目的乘积, 如[2][3] = 2*3 = 6个元素
    }
    va_end(ap);//结束提取变长参数

    array->base = (int *)malloc(elem_total * sizeof(int)); //一大块连续内存存放多维数组的内容
    if(!array->base)
        return -1;
    
    for(i = 0; i < elem_total; i++) { // 测试用的初始化
        array->base[i] = i;    
    }

    array->constants = (int *)malloc(dim * sizeof(int)); 
    // constants辅助进行元素定位, 记录每一维需要增加时需要跨越的元素个数.
    // 如: [2][3], 取[1][2]时, 需要跨越[0][0]~[0][2], [1][0],[1][1]然后取到[1][2], 第1维需要增加是需要跨越
    // [0][0],[0][1],[0][2]三个元素
    if(!array->constants)
        return -1;
    
    array->constants[dim - 1] = 1;
    for(i = dim - 2; i >= 0; --i) {
        array->constants[i] = array->bounds[i+1] * array->constants[i+1];
        // 当前维移动时, 跨越的元素个数为下一维元素个数 与 下一维移动时需要跨越的元素个数
        // 不太好理解, 可以看上面的array[2][3]的例子:
        // 第二维移动时, 只需要跨越1个元素, 比如[0][0]到[0][1]
        // 第一维移动时, 如[0][0]到[1][0], 一定会经历[0][0], [0][1], [0][2], 三个元素, 下一个才是[1][0]
        // 计算为3(第二维元素个数) * 1(第二维移动时需要跨越的元素个数)
    }

    return 0;

}

int locate(array_st *array, va_list ap, int *offset)
{
    int i, ind;

    *offset = 0;
    for(i = 0; i < array->dim; i++) {
        ind = va_arg(ap, int);
        if(ind < 0 || ind > array->bounds[i]) 
            return -1;
        *offset += array->constants[i] * ind;
    }

    return 0;
 }

int assign(array_st *array, int value, ...)
{
    va_list ap;
    int offset;

    va_start(ap, value);
    if(locate(array, ap, &offset) < 0) 
        return -1;
    *(array->base + offset) = value;

    return 0;
}

int main()
{
    int i;
    array_st array;
    
    init_array(&array, 2, 2, 3);
    for(i = 0; i < elem_total; i++) {
        printf("array[%d]:%d\n", i, array.base[i]);
    }
    printf("---------------------------------------------------\n");
    assign(&array, 100, 0, 1);
    for(i = 0; i < elem_total; i++) {
        printf("array[%d]:%d\n", i, array.base[i]);
    }
    return 0;
}

这里头有个没接触过的变长参数系列的东东，度娘告诉我们：

在VC++6.0的include有一个 stdarg.h头文件,有如下几个 宏定义:

#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //第一个可选参数地址

#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址

#define va_end(ap) ( ap = (va_list)0 ) // 将指针置为无效