线性表的顺序表示

一、顺序表的定义

1.定义   

线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素物理位置上也相邻。特点是元素的逻辑顺序和物理顺序相同。

       假设线性表L存储起始位置为LOC(A)，sizeof(ElemType)是每个数据元素所占用存储空间的大小，则表L对应的顺序存储如下图所示

数组下标	顺序表	内存地址
0	a1	LOC(A)
1	a2	LOC(A)+sizeof(ElemType)
	…
i-1	ai	LOC(A)+(i-1)*sizeof(ElemType)
	…
n-1	an	LOC(A)+(n-1)*sizeof(ElemType)
	…
MaxSize-1	…	LOC(A)+(MaxSize-1)*sizeof(ElemType)

注意：线性表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。

 

2.内存分配

（1）静态分配

       静态分配就是提前固定数组的大小和空间，一旦空间占满，再加入新的数据会溢出，进而导致程序崩溃。提前在输入结果中就是会出现很长很长的数字。

       假定线性表的元素类型为ElemType，则静态分配表示如下：

#define MaxSize 100            //定义线性表的最大长度
typedef struct{
    ElemType data[MaxSize];    //顺序表的元素
    int length;
}SqList;                       //顺序表的类型定义

（2）动态分配

       动态分配是指存储数组的空间在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就开辟一块更大的存储空间，达到扩充的目的。

       动态分配表示如下：     

#define InitSize 100           //表长度的初始定义
typedef struct{
    ElemType *data;            //指示动态分配数组的指针
    int MaxSize,length;        //数组的最大容量和当前个数
}SeqList;                      //动态分配数组顺序表的类型定义

       C的初始动态分配语句为：

       L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

       C++的初始动态分配语句为：

       L.data=new ElemType[InitSize];

注意：动态分配不属于链式存储，物理结构没有变化，只是分配的空间大小可以在运行时决定。

 

3.顺序表的特点

（1）随机访问，即通过首地址和元素序号可在时间O(1)内找到指定的元素；

（2）存储密度高，每个结点只存储数据元素；

（3）逻辑上相邻的元素物理上也相邻，插入和删除需要移动大量元素。

 

二、顺序表上基本操作的实现

       基本操作：增删改查（在分析其他数据结构的时候也一样）。

1.插入操作

       在顺序表第i个位置插入一个元素x。若i不合法返回false，否则将顺序表中第i个元素及以后所有元素右移一个位置，在空位置插入x，顺序表长度加1，插入成功，返回true。

       图例：

      插入之前

	0	1	2	3	4	5	6
data	1	2	3	4	5	6

      插入之后：在2位置插入7

	0	1	2	3	4	5	6
data	1	2	7	3	4	5	6

       具体代码如下：

bool ListInsert(SqList &L, int i, ElemType x)    //将x插入至位置i
{
    if(i<1||i>L.length+1)                        //判断i的范围是否有效
        return false;
    if(L.length>=MaxSize)                        //储存空间已满，不能插入
        return false;
    for(int j=L.length; j>=i; j--)               //将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];                   //将前一个的值赋给后一个
    L.data[i-1]=x;                               //在位置i处放入x
    L.length++;                                  //线性表长度加1
}

注意：在这里我们要注意位序和数组下标是不同的，前面提到过这个问题。

       插入操作的平均时间复杂度为O(n)。

 

2.删除操作

       删除操作和插入操作很像，就是将第i个元素以后所有元素左移一个位置。

       图例：

      删除之前

	0	1	2	3	4	5	6
data	1	2	7	3	4	5	6

      删除之后：在2位置删除7

	0	1	2	3	4	5	6
data	1	2	3	4	5	6

       具体代码如下：

bool ListDelete(SqList &L, int i)           //删除第i个位置的元素
{
    if(i<1||i>L.length)                     //判断i的范围是否有效
        return false;
    for(int j=i; j<L.length; j++)           //将第i个位置以后的元素前移
        L.data[j-1]=L.data[j]
    L.length--;                             //线性表长度减一
    return true;
}

       在这里我们使用的是删除某个位置i的元素，但是在很多情况下，我们不知道我们想删除的元素在那个位置，可以利用如下语句结合上面代码删除指定值：

for(int i=0; i<L.length; i++)
{
    if(L.data[i]==x)
        temp=i;
}

       这里只是给出了一个参考，结合起来就OK。

       同样的，删除操作的平均时间复杂度也为O(n)。

 

3.按值查找

       就是顺序查找，在顺序表中实现比较简单。

       具体代码如下：

int LocateElem(SqList L, ElemType x)    //查找为x的元素值
{
    int i;
    for(i=0; i<L.length; i++)
        if(L.data[i]==x)
            return i+1;                 //下标为i的元素值等于x,返回其位序i+1
    return 0;                           //查找失败
}

        同样的，按值查找操作的平均时间复杂度也为O(n)。

这是补充：为啥线性表的顺序存储和数组有啥不一样呢？数组是线性表的推广，一维数组可以看作一个线性表；二维数组可视为元素是线性表的线性表。有点绕，多理解理解，动手写一写就明白了！