數組存儲原理學習

1.基本概念

數組的定義：
   在印象中數組往往是某一門編程語言中包含的具體數據類型，其實不然。
   從本質上講，數組與順序表、鏈表、棧和隊列一樣，都用來存儲具有 "一對一" 邏輯關系數據的線性存儲結構。
   只因各編程語言都默認將數組作為基本數據類型，使初學者對數組有了 "只是基本數據類型，不是存儲結構" 的誤解。

特點：
  不僅如此，數組和其他線性存儲結構不同，順序表、鏈表、棧和隊列存儲的
  都是不可再分的數據元素（如數字 5、字符 'a' 等），
  而數組既可以用來存儲不可再分的數據元素，
  也可以用來存儲像順序表、鏈表這樣的數據結構。

  比如說，數組可以直接存儲多個順序表。我們知道，順序表的底層實現還是數組，
  因此等價於數組中繼續存儲數組。這與平時使用的二維數組類似。

結構：
  根據數組中存儲數據之間邏輯結構的不同，數組可細分為一維數組、二維數組、...、n 維數組：
  （1）一維數組，指的是存儲不可再分數據元素的數組，如圖 1 所示；
      

 

    （2）二維數組，指的存儲一維數組的一維數組，如圖 2 所示；

      

    （3）n 維數組，指的是存儲 n-1 維數組的一維數組；

      ps:無論數組的維數是多少，數組中的數據類型都必須一致。

 

2.數組的順序存儲及（C語言）實現數組插入和刪除的效率差的原因  數組作為一種線性存儲結構，對存儲的數據通常只做查找和修改操作，  因此數組結構的實現使用的是順序存儲結構。  要知道，對數組中存儲的數據做插入和刪除操作，算法的效率是很差的。

存儲方式：
  由於數組可以是多維的，而順序存儲結構是一維的，
  因此數組中數據的存儲要制定一個先后次序。
  通常，數組中數據的存儲有兩種先后存儲方式：

    1.以列序為主（先列后行）：按照行號從小到大的順序，依次存儲每一列的元素
    2.以行序為主（先行后序）：按照列號從小到大的順序，依次存儲每一行的元素

  多維數組中，我們最常用的是二維數組。
  比如說，當二維數組 a[6][6] 按照列序為主的次序順序存儲時，
  數組在內存中的存儲狀態如圖 1 所示：
    

 

    同樣，當二維數組 a[6][6] 按照行序為主的次序順序存儲時，

    數組在內存中的存儲狀態如圖 2 所示：

    

 

   ps:C 語言中，多維數組的存儲采用的是以行序為主的順序存儲方式。

多維數組查找指定元素:
   當需要在順序存儲的多維數組中查找某個指定元素時，
   需知道以下信息：

     1.多維數組的存儲方式
     2.多維數組在內存中存放的起始地址
     3.該指定元素在原多維數組的坐標（比如說，二維數組中是通過行標和列標來表明數據元素的具體位置的）
     4.數組中數組的具體類型，即數組中單個數據元素所占內存的大小，通常用字母 L 表示

  根據存儲方式的不同，查找目標元素的方式也不同。
  如果二維數組采用以行序為主的方式，則在二維數組 a(nm)中查找a(ij)存放位置的公式為：

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

  其中，LOC(i,j) 為 a(ij)在內存中的地址，LOC(0,0) 
  為二維數組在內存中存放的起始位置（也就是 a(00)的位置）。   

  而如果采用以列存儲的方式，在 a(nm)中查找 a(ij)的方式為：
     LOC(i,j) = LOC(0,0) + (i*n + j) * L;
  

例子：
  采用以行序為主的方式存儲三維數組 a[3][4][2] 的 C 語言代碼實現：

#include<stdarg.h>
#include<malloc.h>
#include<stdio.h>
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h>
#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;
}

運行結果：

A.bounds=3 4 2
A.constants=8 2 1
3頁4行2列矩陣元素如下:
A[0][0][0]= 0 A[0][0][1]= 1
A[0][1][0]=10 A[0][1][1]=11
A[0][2][0]=20 A[0][2][1]=21
A[0][3][0]=30 A[0][3][1]=31

A[1][0][0]=100 A[1][0][1]=101
A[1][1][0]=110 A[1][1][1]=111
A[1][2][0]=120 A[1][2][1]=121
A[1][3][0]=130 A[1][3][1]=131

A[2][0][0]=200 A[2][0][1]=201
A[2][1][0]=210 A[2][1][1]=211
A[2][2][0]=220 A[2][2][1]=221
A[2][3][0]=230 A[2][3][1]=231

A.base=
   0   1  10  11  20  21  30  31
100 101 110 111 120 121 130 131
200 201 210 211 220 221 230 231  

 

學習來源：

 //基本概念

  http://data.biancheng.net/view/181.html