顺序表

动态分配与扩容

typedef struct {
    ELemtype *data;
    int len;
    int maxSize;
}SqList;

void InitList(SqList &L)
{
    L.data = (ELemtype *)malloc(sizeof(ELemtype) * InitSIze);
    L.len = 0;
    L.maxSize = InitSIze;
}

void IncreaseSize(SqList &L, int m)  //m代表扩展的容量
{
    ELemtype *p = L.data;
    L.data = (ELemtype *)malloc(sizeof(ELemtype) * (m + L.maxSize));
    for(int i = 0; i < L.len; ++i)
        L.data[i] = p[i];
    L.maxSize += m;
    free(p);
}

静态分配

typedef struct {
    ELemtype data[MAXSIZE];
    int len;
}SqList;

void InitList(SqList &L)
{
    for(int i = 0; i < MAXSIZE; ++i) //内存可能存在脏数据
        L.data[i] = 0;
    L.len = 0;
}

插入

在第i个位置插入元素e(位序从1开始)

最坏情况： 插入位置在顺序表起始位置，需要后移n个元素，后移n次，O(n)

最好情况： 插入位置在顺序表末尾位置，不需要后移元素，后移0次，O(1)

平均情况 每个位置的概率都为1/(n + 1), 平均需要进行 1/(n + 1) * (0 + 1 + 2 + ... + n ) = 1/(n + 1) * (n + 1)n/2 = n/2 次后移，O(n)

//在第i个位置插入元素e(位序从1开始)
bool ListInsert(SqList &L, int i, ELemtype e)
{
    if(i < 1 || i > L.len + 1)
        return false;
    if(L.len >= MAXSIZE)
        return false;
    for(int j = L.len; j >= i; --j)
        L.data[j] = L.data[j - 1];
    L.len++;
    L.data[i - 1] = e;
    return true;
}

删除

删除第i个位置的元素，并将删除结果保存到e中(位序从1开始)

最坏情况： 删除位置在顺序表起始位置，需要前移n-1个元素，前移n-1次，O(n)

最好情况： 删除位置在顺序表末尾位置，不需要前移元素，前移0次，O(1)

平均情况 每个位置的概率都为1/n, 平均需要进行 1/n * (0 + 1 + 2 + ... + (n-1) ) = 1/n * (n - 1)n/2 = (n - 1)/2 次前移，O(n)

//删除第i个位置的元素，并将删除结果保存到e中(位序从1开始)
bool ListDelete(SqList &L, int i, ELemtype &e)
{
    if(i < 1 || i > L.len)
        return false;
    e = L.data[i - 1];
    for(int j = i; j < L.len; ++j)
        L.data[j - 1]  = L.data[j];
    L.len--;
    return true;
}

按位查找

//时间复杂度O(1)
ELemtype GetElem(SqList L, int i)
{
    return L.data[i - 1];
}

按值查找

返回的为位序

int LocateElem(SqList L, ELemtype e)
{
    for(int i = 0; i < L.len; ++i)
        if(L.data[i] == e)
            return i + 1;
    return 0;
}