2.2 线性表的顺序表示

2.2 线性表的顺序表示

2.2.1 顺序表的定义

用顺序存储方式实现的线性表叫做顺序表。它是由一组地址连续的存储单元依次存储线性表中的元素，从而使得逻辑上相邻，物理上也相邻。

顺序表的实现–静态分配

typedef struct SqList
{
    int data[50];       //用静态的数组存放数据元素
    int length;         //顺序表的长度
};

Q：如果“数组”存满了怎么办？

A：没办法，因为顺序表的表长是刚开始就确定的，无法更改，（存储空间是静态的）

顺序表的实现–动态分配

typedef struct SeqList
{
    int *data;          //指示动态分配数组的指针
    int Maxsize, length;//数组的最大容量和当前个数
};

[注意：动态分配并不是链式存储，它同样属于顺序存储结构，物理结构没有变化，依然是随机存取方式，只是分配的空间大小可以在运行时动态决定。]

顺序表的特点：

1. 随机访问，即可以在O（1）时间内找到第i个元素。
2. 存储密度高，每个节点只存储数据元素。
3. 扩展容量不方便（即使采用动态分配方式，扩展长度的时间复杂度也比较高）
4. 插入、删除不方便，需要移动大量元素。

2.2.2 顺序表上基本操作的实现

仅讨论初始化、插入、删除和按值查找，其他的基本操作都比较简单。

1.顺序表的初始化

静态分配在声明顺序表的时候就分配了数组空间，因此只需要将当前length设置为0。

void InitList(SqList &L){
    L.length = 0;
}

动态分配的初始化为顺序表分配一个预定义大小的数组空间，并将顺序表的当前长度设为0。MaxSize指示当前分配空间大小，如果插入空间而元素不足，就进行再分配。

void InitList(SeqList &L){
    L.data = (int *)malloc(Initsize*sizeof(int));
    L.length = 0;
    L.Maxsize = Initsize;
}

增加动态数组的长度：

void IncreaseSize(SeqList &L, int len){
    int *p = L.data;
    L.data = (int *)malloc((L.Maxsize+len)*sizeof(int));
    for(int i = 0; i<L.length; i++){
        L.data[i] = p[i];
    }
    L.Maxsize+=len;
    free(p);
}

2.插入操作（静态数组）

在顺序表的第i个位置插入元素e。

bool ListInsert(SqList &L, int i, int e){
    if(i < 1 || i > L.length+1){
        printf("插入非法位置！\n");     //处理异常情况
        return false;
    }
    if(L.length >= Maxsize){
        printf("表已满\n");             //处理异常情况
        return false;
    }
    for(int j = L.length;j >= i; j--){
        L.data[j] = L.data[j-1];        //将第i个元素和后面的元素往后移动一位
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

时间复杂度：

最好情况：插入的位置是最后一个，不需要移动元素，时间复杂度为O(1)；

最坏情况：插入的位置是第一个，需要移动n个元素，时间复杂度为O(n)；

平均情况：（0+n）（n+1）/2（n+1）=n/2，因此平均复杂度是O(n)。

3.删除操作

删除顺序表中第i个元素，并引用变量e返回删除值。

和插入操作类似，也是定位到第i个元素，然后删除，并将后面的元素往前移动一个。

bool ListDelete(SqList &L, int i, int &e){
    if(i < 1 || i > L.length+1){
        printf("删除位置非法！\n");     //处理异常情况
        return false;
    }
    e = L.data[i-1];                    //存放删除的元素
    for(int j = i;j < L.length; j++){
        L.data[j-1] = L.data[j];        //往前移动元素
    }
    L.length-=1;
    return true;
        
}

时间复杂度：

最好情况：删除的位置是最后一个，不需要移动元素，时间复杂度为O(1)；

最坏情况：删除的位置是第一个，需要移动n-1个元素，时间复杂度为O(n)；

平均情况：（0+n）（n-1）/2（n）=（n-1）/2，因此平均复杂度是O(n)。

4.按值查找（顺序查找）

按位查找过于简单，在此不展示。

在顺序表L中查找第一个元素值为e的元素，并返回其次序。

int LocateElem(SqList &L, int e){
    for(int i = 0; i < L.length; i++){
        if(L.data[i] == e){
            return i+1;             //寻找值为e的元素并返回其位次
        }
    }
    return -1;                      //如果没找到则返回-1，用于表示没找到
}

时间复杂度：

最好情况：寻找的元素的位置是最一个，不需要比较元素，时间复杂度为O(1)；

最坏情况：插入的位置是最后一个，需要比较n个元素，时间复杂度为O(n)；

平均情况：（0+n）（n+1）/2（n+1）=n/2，因此平均复杂度是O(n)。