【数据结构】一、顺序表

目录

1 顺序表的实现

1.1.静态实现：

1.2. 动态实现：

2. 顺序表的基本操作

2.1 插入：

2.2 删除

2.3 按位查找

2.4  按值查找

---

1 顺序表的实现

1.1.静态实现：

#define MaxSize 10 // 定义最大长度 

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

// 初始化顺序表 
void InitList(SqList &L) {
        L.length = 0; // 顺序表初始长度为0 
}

int main() {
        SqList L; // 声明一个顺序表 
        InitList(L); // 初始化顺序表 
        return 0;
}

1. 1.2. 动态实现：

#define InitSize 10 // 顺序表的初始长度

typedef struct {
        int *data; // 声明动态分配数组的指针 
        int MaxSize; // 顺序表的最大容量
        int length; // 顺序表的当前长度 
}SeqList;

// 初始化顺序表 
void InitList(SqList &L) {
        // 用malloc函数申请一片连续的存储空间 
        L.data = (int *)malloc(InitSize * sizeof(int));
        L.length = 0;
        L.MaxSize = InitSize;
}

// 增加动态数组的长度 
void IncreaseSize(SqList &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 = L.MaxSize + len; // 顺序表最大长度增加len 
        free(p); // 释放原来的内存空间 
}

int main() {
        SeqList L; // 声明一个顺序表 
        InitList(L); // 初始化顺序表 
    ...
        IncreaseSize(L, 5);
        return 0;
}

2. 顺序表的基本操作

2.1 插入：

#define MaxSize 10 // 定义最大长度 

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

// 在顺序表i位置插入e
bool ListInsert(SqList &L, int i, int e) {
        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] = e; // 在位置i处放入e 
        L.length++; // 长度+1 
        return true;
} 

int main() {
        SqList L;
        InitList(L);
        ListInsert(L, 3, 3);
        return 0; 
} 
时间复杂度：
1.	最好时间复杂度： O ( 1 )
2.	最坏时间复杂度： O ( n )
3.	平均时间复杂度： O ( n )

2.2 删除

#define MaxSize 10

typedef struct {
        int data[MaxSize];
        int length;
} SqList;

// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {
        if (i < 1 || i > L.length) // 判断i的范围是否有效
                return false;
        e = L.data[i-1]; // 将被删除的元素赋值给e 
        for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 
                L.data[j-1] = L.data[j];
        L.length--;
        return true; 
}

int main() {
        SqList L;
        InitList(L);
        int e = -1;
        if (ListDelete(L, 3, e))
                printf("已删除第3个元素，删除元素值为%d\n", e);
        else
                printf("位序i不合法，删除失败\n"); 
        return 0; 
} 
时间复杂度：
1.	最好时间复杂度： O ( 1 )
2.	最坏时间复杂度： O ( n )
3.	平均时间复杂度： O ( n )

2.3 按位查找

// 静态分配的按位查找
#define MaxSize 10

typedef struct {
        ElemType data[MaxSize]; 
        int length;
}SqList;

ElemType GetElem(SqList L, int i) {
        return L.data[i-1];
}
// 动态分配的按位查找
#define InitSize 10

typedef struct {
        ElemType *data;
        int MaxSize;
        int length;
}SeqList;

ElemType GetElem(SeqList L, int i) {
        return L.data[i-1];
}
时间复杂度： O ( 1 )

2.4  按值查找

#define InitSize 10

typedef struct {
        ElemType *data; 
        int MaxSize;
        int length; 
}SqList;

// 查找第一个元素值为e的元素，并返回其位序 
int LocateElem(SqList L, ElemType e) {
        for (int i = 0; i < L.length; i++)
                if (L.data[i] == e)
                        return i+1; // 数组下标为i的元素值等于e，返回其位序i+1 
        return 0; // 没有查找到 
}
在《数据结构》考研初试中，手写代码可以直接用“==”，无论 ElemType 是基本数据类型还是结构类型
时间复杂度：
3.	最好时间复杂度： O ( 1 )
4.	最坏时间复杂度： O ( n )
5.	平均时间复杂度： O ( n )