顺序表—线性表的顺序表示

---

前言

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

※※※ 顺序表的主要特点：

①随机存取：通过首地址和元素序号可以在 O(1) 时间内找到和操作指定的元素。

②存储密度高：每个结点只存储数据元素。

③逻辑上相邻的元素物理上也相邻：数组的性质，内存上开辟的是一串连续的空间。因此，插入和删除操作需要移动大量的元素。

【注】由于顺序表的这些特点，使得顺序表在插入和删除操作时需要大量的数据移动操作。

---

一、静态分配—静态一维数组

1.存储空间示意图

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

2.C/C++语言-顺序表结构体定义

写入 SeqList.h 头文件，可在 .cpp 文件中引用：

#include<iostream>
#define MaxSize 50  // 定义容量为 50
using namespace std;
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];  // 以 MaxSize 为容量的，数据元素为 int 型的数组
    int length;  // 记录顺序表当前长度
} SeqList;  // 结构体别名为 SeqList

二、动态分配—动态申请存储空间

1.概念简介

前面的 SeqList 是静态的一维数组形式，在运用过程中会很不方便。该顺序表一旦定义，数组的大小和空间就不能改变。
一旦静态数组的空间占满，再加入新的数据就会产生溢出。
于是有一种动态申请内存空间的方式，即在原始空间占满时，另外申请更大的一片存储空间，并将原来的数据复制到新的空间内。
这样一来，就相当于动态地扩充顺序表的容量，不再轻易发生溢出的情况。

2.结构体定义

写入 SeqList_Dynamic.h 文件：

#include<iostream>
#define InitSize 5  // 顺序表初始容量
using namespace std;
typedef int ElemType;
typedef struct{
    ElemType *data;  // 动态分配数组的指针
    int length, MaxSize;  // 数组的当前长度和最大容量
}SeqList_Dynamic;

数组（连续存储空间）动态分配语句为：

// C++语言
L.data = new ElemType[InitSize];
// C语言
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);

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

下图是动态分配空间的简易图解：

---

三、顺序表的基本抽象数据类型ADT

1.打印输出 - PrintList

函数名 PrintList(SeqList L)
打印输出顺序表存储的数据，便于查看结果。

#include "SeqList.h"
void PrintList(SeqList L) {
    for (int i = 0; i < L.length; i++) {
        cout<<L.data[i]<<" ";  // 遍历数组输出
    }
    cout<<"\n";
}

2.中间插入 - ListInsert

函数名 ListInsert(SeqList &L, int i, ElemType e)
在顺序表位置为 i 处插入元素 e ，元素依次后移（覆盖）。

#include "SeqList.h"
bool ListInsert(SeqList &L, int i, ElemType e) {
	if (i<1||i>L.length+1) return false;  // 判断 i 的范围是否有效
	if (L.length>=MaxSize) return false;  // 判断空间是否已满
	for (int j=L.length; j>=i; j--)
		L.data[j] = L.data[j-1];  // 第 i 个及其之后的元素后移
	L.length++;  // 顺序表长度加 1
	L.data[i-1] = e;  // 在位置 i 存入 e
	return true;
}

插入操作示例：

给定 i = 3, e = 50 和初始数组，插入操作 ListInsert(SeqList &L, int i, ElemType e) 示意图如下：
①-②：将位置 i 及其之后的元素依次后移覆盖；
③：将位置 i 的元素赋值为 50 。

3.删除 - ListDelete

函数名 ListDelete(SeqList &L, int i, ElemType &e)
删除顺序表位置为 i 的元素，其后元素依次前移（覆盖）。

#include "SeqList.h"
bool ListDelete(SeqList &L, int i, ElemType &e) {
	if (i<1||i>L.length) return false;  // 判断 i 的范围是否有效
	e = L.data[i-1];  // 将要被删除的元素赋值给 e
	for (int j=i; j<L.length; j++)
		L.data[j-1] = L.data[j];  // 第 i 个及其之后的元素前移
	L.length--;  // 顺序表长度-1
	return true;
}

删除操作示例：

给定 i = 4 和初始数组，删除操作 ListDelete(SeqList &L, int i, ElemType &e) 示意图如下：
①：将位置 i 之后的元素依次前移覆盖；
②：表的当前长度减1。
需要注意的是，最后一个元素可以不予理会，可以赋值为 0 ，满足强迫症，但不管它也不会有什么影响。

4.查找 - LocateElem

函数名: LocateElem(SqList L, ElemType e)
查找顺序表中是否存在元素 e ：
存在则返回其位置 (数组下标+1) ；不存在则返回 0(判断语句中即false) 。

#include "SeqList.h"
int LocateElem(SeqList L, ElemType e) {
	for (int i=0; i<L.length; i++) {
		if (L.data[i]==e) return i+1;  // 遍历数组，匹配元素 e
	}
	return 0;
}

四、操作演示

以下内容写入 main.cpp ：

#include "SeqList.h"
// 打印数组
void PrintList(SeqList L) {
    for (int i = 0; i < L.length; i++) {
        cout<<L.data[i]<<" ";  // 遍历数组输出
    }
    cout<<"\n";
}
// 插入
bool ListInsert(SeqList &L, int i, ElemType e) {
	if (i<1||i>L.length+1) return false;  // 判断 i 的范围是否有效
	if (L.length>=MaxSize) return false;  // 判断空间是否已满
	for (int j=L.length; j>=i; j--)
		L.data[j] = L.data[j-1];  // 第 i 个及其之后的元素后移
	L.length++;  // 顺序表长度加 1
	L.data[i-1] = e;  // 在位置 i 存入 e
	return true;
}
// 删除
bool ListDelete(SeqList &L, int i, ElemType &e) {
	if (i<1||i>L.length) return false;  // 判断 i 的范围是否有效
	e = L.data[i-1];  // 将要被删除的元素赋值给 e
	for (int j=i; j<L.length; j++)
		L.data[j-1] = L.data[j];  // 第 i 个及其之后的元素前移
	L.length--;  // 顺序表长度-1
	return true;
}
// 查找定位
int LocateElem(SeqList L, ElemType e) {
	for (int i=0; i<L.length; i++) {
		if (L.data[i]==e) return i+1;  // 遍历数组，匹配元素 e
	}
	return 0;
}

int main() {
    SeqList L;
    L.data[0] = 12;
    L.data[1] = 23;
    L.data[2] = 6;
    L.data[3] = 2;
    L.data[4] = 34;
    L.data[5] = 11;
    L.data[6] = 7;
    L.length = 7;  // 手动创建顺序表

    cout<<"初始表：";
    PrintList(L);
    cout<<"表长为 "<<L.length<<endl;
    cout<<"---------------"<<endl;
    
	// 插入
    ListInsert(L, 3, 56);  
    cout<<"插入后：";
    PrintList(L);
    cout<<"表长为 "<<L.length<<endl;
    cout<<"---------------"<<endl;

	// 删除
    int e; // 查看删除的返回值
    ListDelete(L,2,e);  
    cout<<"删除元素："<<e<<endl;
    cout<<"删除后：";
    PrintList(L);
    cout<<"表长为 "<<L.length<<endl;
    cout<<"---------------"<<endl;

	// 查找定位
    int index = LocateElem(L, 2);  
    cout<<"2 所在位置:"<<index<<endl;
    return 0;
}

运行程序，输出结果为：

初始表：12 23 6 2 34 11 7 
表长为 7
---------------
插入后：12 23 56 6 2 34 11 7
表长为 8
---------------
删除元素：23
删除后：12 56 6 2 34 11 7
表长为 7
---------------
2 所在位置:4

总结

主要记录相关概念及知识点，后续将记录更多的 ADT(抽象数据类型) 的实际操作。
——2023/2/27
本次更新完成，顺序表的概念及 ADT 告一段落。
——2023/2/28