（大家好，今天分享的是数据结构的相关知识，大家可以在评论区进行互动答疑哦~加油！💕）
目录
提要：实验题目
一、实验目的
二、实验内容及要求
三、算法思想
实验1
实验2
四、源程序及注释
实验1代码（顺序存储结构）
实验2代码（链式存储结构）
五、实验结果
实验1结果
实验2结果
提要：实验题目
1. 线性表顺序存储结构下基本操作的实现
2. 线性表链式存储结构下基本操作的实现
一、实验目的
- 1．掌握线性表的顺序存储表示和链式存储表示。
- 2．掌握顺序表和链表的基本操作算法，包括创建、取值、查找、插入、删除等基本操作的实现。
- 3．了解线性表两种不同存储结构的特点，会灵活运用线性表解决某些实际问题。
二、实验内容及要求
- 1．线性表顺序存储结构下基本操作的实现（初始化、建表、取值、查找、插入、删除、两个非递减有序链表的归并等）。
- 2．线性表链式存储结构下基本操作的实现（初始化、建表、取值、查找、插入、删除、两个非递减有序链表的归并等）。
三、算法思想
实验1
（1.）初始化
初始化操作主要涉及到为顺序表分配内存空间，并设置其初始状态。通过定义一个顺序表的结构体，并为其动态分配一个足够大小的数组来完成。算法上，是内存分配的过程。
（2.）建表
建表操作是在初始化后的顺序表中填充数据元素。这是通过遍历一个给定的数据集合（如数组），并将每个元素依次存入顺序表的数组中来实现。算法上，这是一个简单的遍历过程。
（3.）取值
取值操作是根据给定的位置索引，从顺序表中获取对应位置上的数据元素。由于顺序表的数据元素在内存中连续存放，因此可以通过直接计算偏移地址来获取所需元素。算法上，这是一个简单的数组访问操作。
（4.）查找
查找操作是在顺序表中搜索具有给定值的元素，并返回其位置索引。通过遍历整个顺序表来查找元素
（5.）插入
插入操作是在顺序表的指定位置插入一个新的数据元素。这涉及到将指定位置及其之后的所有元素向后移动一个位置，为新元素腾出空间。算法上，这涉及到元素的移动操作。
（6.）删除
删除操作是从顺序表的指定位置移除一个数据元素。这涉及到将指定位置之后的所有元素向前移动一个位置，以填补被删除元素留下的空白。算法上，这涉及到元素的移动操作。
（7.）两个非递减有序链表的归并
归并算法通过遍历两个链表，比较当前节点的值，选择较小的节点接入新链表中，并移动指针继续比较，直到所有节点都被遍历完。这涉及到创建一个新的顺序表或数组来存储归并后的结果，并通过双指针技术来遍历两个原顺序表或数组。
实验2
基本算法思想一致
四、源程序及注释
实验1代码（顺序存储结构）
#include <iostream> // 输入输出流头文件
#include <fstream> // 文件操作头文件
#include <string> // 字符串操作头文件
#include <iomanip> // 输入输出操纵运算头文件
using namespace std; // 调用命名空间std中所有标识符，简化标准库函数的调用
#define MAXSIZE 1000 // 定义数组的最大容量
// 预定义常量及预定义类型
#define OK 1 // 操作成功时的返回值
#define ERROR 0 // 操作失败时的返回值
#define OVERFLOW -2 // 内存溢出错误的返回值
typedef int Status; // 定义Status为返回值类型，用于表示函数的执行状态
// 定义Book结构体来存储书籍的信息
typedef struct
{
int id; // 书籍的ISBN编号
double price; // 书籍的价格
} Book;
// 定义顺序表（顺序存储的线性表）结构体，用于存储一组书籍
typedef struct
{
Book *elem; // 指向存储书籍的动态数组
int length; // 顺序表的当前长度
} SqList;
// 1.初始化
Status initList(SqList &L)
{
L.elem = new Book[MAXSIZE]; // 动态分配最大容量的数组空间
if (!L.elem) // 如果内存分配失败
exit(OVERFLOW); // 退出程序并返回溢出错误
L.length = 0; // 初始化顺序表长度为0
return OK; // 返回成功状态
}
// 3.取值
Status GetElem(SqList L, int i, Book &e)
{
if (i < 1 || i > L.length) // 检查i是否超出有效范围
return ERROR; // 返回错误状态
e = L.elem[i - 1]; // 获取第i个元素（数组下标从0开始）
return OK; // 返回成功状态
}
// 4.查找
int LocateElem(SqList L, Book e)
{
for (int i = 0; i < L.length; i++) // 遍历顺序表中的每本书
{
if (L.elem[i].id == e.id) // 如果找到匹配的ISBN编号
return i + 1; // 返回位置（从1开始）
}
return 0; // 未找到，返回0
}
//5.插入
Status ListInsert(SqList &L, int i, Book e)
{
if ((i < 1) || (i > L.length + 1)) // 判断要插入的位置是否合法。
return ERROR;
if (L.length == MAXSIZE) // 判断当前列表是否已经满了，如果满了就返回ERROR
return ERROR;
for (int j = L.length - 1; j >= i - 1; j--)
{
L.elem[j + 1] = L.elem[j];
}
L.elem[i - 1] = e;
++L.length;
return OK;
}
//6. 删除
Status ListDelete(SqList &L, int i)
{
// 在顺序表中删除第i个元素, i值的合法范围是1<=i<=L.length
if ((i < 1) || (i > L.length))
return ERROR; // 不合法，返回错误状态
// 从位置 i 开始，将后面的元素依次向前移动
for (int j = i; j < L.length; j++)
{
L.elem[j - 1] = L.elem[j]; // 将位置 j 的元素赋值给位置 j-1
}
--L.length; // 顺序表长度减少 1
return OK; // 返回成功状态
}
//7. 归并
/*给定两个非递减有序的顺序表 A 和 B，将它们合并成一个新的非递减有序的顺序表 C。
合并步骤：
创建一个新的顺序表 C，它的长度是 A 和 B 的长度之和。
设置两个指针 i 和 j，分别指向顺序表 A 和 B 的起始位置。
比较 A[i] 和 B[j]：
如果 A[i] <= B[j]，将 A[i] 放入 C，然后指针 i 右移。
否则，将 B[j] 放入 C，然后指针 j 右移。
当其中一个顺序表（A 或 B）的所有元素都被处理完后，将另一个顺序表剩余的元素直接放入 C。
返回合并后的顺序表 C。 */
// 归并两个非递减有序的顺序表L和A到B
Status MergeList(SqList L, SqList A, SqList &B)
{
int i = 0, j = 0, k = 0; // 初始化指针
B.length = A.length + L.length; // B的长度为A和L之和
B.elem = new Book[B.length]; // 为B分配空间
if (!B.elem) // 检查内存分配
return OVERFLOW;
// 归并过程：当L和A都还有元素时进行比较
while (i < L.length && j < A.length)
{
if (L.elem[i].id <= A.elem[j].id)
{
B.elem[k++] = L.elem[i++]; // L的元素较小，放入B
}
else
{
B.elem[k++] = A.elem[j++]; // A的元素较小，放入B
}
}
// 如果L还有剩余元素，直接放入B
while (i < L.length)
{
B.elem[k++] = L.elem[i++];
}
// 如果A还有剩余元素，直接放入B
while (j < A.length)
{
B.elem[k++] = A.elem[j++];
}
return OK; // 返回成功状态
}
// 9. 清空数据表
// 功能：释放顺序表的动态数组并将其长度重置为0
Status ClearList(SqList &L)
{
if (L.elem) // 如果顺序表已经有元素
{
delete[] L.elem; // 释放动态分配的内存
L.elem = nullptr; // 将指针设为nullptr，防止悬空指针
}
L.length = 0; // 将顺序表长度重置为0
return OK;
}
// 函数：将顺序表B的值赋给L
// 功能：清空L后，将B的值复制到L中
Status AssignList(SqList &L, SqList B)
{
ClearList(L); // 先清空L
L.elem = new Book[B.length]; // 为L分配与B相同长度的内存
if (!L.elem) // 检查内存分配是否成功
return OVERFLOW;
for (int i = 0; i < B.length; i++) // 复制B中的每个元素到L
{
L.elem[i] = B.elem[i];
}
L.length = B.length; // 更新L的长度
return OK;
}
// 函数：显示菜单
// 功能：输出用户可执行的操作菜单
void showMenu()
{
cout << "****************************\n";
cout << "**** 1. 初始化 ****\n";
cout << "**** 2. 赋值 ****\n";
cout << "**** 3. 取值 ****\n";
cout << "**** 4. 查找 ****\n";
cout << "**** 5. 插入 ****\n";
cout << "**** 6. 删除 ****\n";
cout << "**** 7. 归并 ****\n";
cout << "**** 8. 输出 ****\n";
cout << "**** 9. 清空数据表 ****\n";
cout << "**** 0. 退出 ****\n";
cout << "****************************\n";
}
// 主函数
int main()
{
SqList L, A, B; // 定义顺序表L A B
Book e; // 定义书籍e
int count, i, ps; // count用于存储书籍的数量，i用于索引,ps为元素的位置
int choose = -1; // 用户选择的操作，初始化为-1
showMenu(); // 显示操作菜单
while (choose != 0) // 当用户选择不是0（退出）时，继续操作
{
cout << "请选择操作（0-8）:"; // 提示用户输入操作
cin >> choose; // 读取用户选择
switch (choose) // 根据选择执行对应的操作
{
case 1: // 初始化顺序表
initList(L); // 调用初始化函数
cout << "初始化顺序表成功：\n"; // 输出提示
break;
case 2: // 赋值
cout << "请输入图书的个数："; // 提示用户输入书籍数量
cin >> count; // 读取书籍数量
cout << "请输入图书的信息（ISBN编号 价格）：\n"; // 提示用户输入书籍信息
for (i = 0; i < count; i++) // 循环输入每本书籍的信息
cin >> L.elem[i].id >> L.elem[i].price; // 输入书籍的ISBN编号和价格
L.length = count; // 更新顺序表的长度
break;
case 3: // 取值
cout << "请输入位置："; // 提示用户输入位置
cin >> i; // 读取位置
GetElem(L, i, e); // 调用取值函数
cout << e.id << "\t" << e.price << endl; // 输出书籍的ISBN编号和价格
break;
case 4: // 查找
cout << "请输入ISBN号码："; // 提示用户输入要查找的ISBN编号
cin >> e.id; // 读取ISBN编号
cout << LocateElem(L, e) << endl; // 调用查找函数并输出结果
break;
case 5:
// 插入
cout << "请输入要插入的位置\n";
cin >> ps; // 读取插入位置
cout << "请输入图书的信息（ISBN编号 价格）："; // 提示用户输入书籍信息
cin >> e.id >> e.price; // 读取书籍的ISBN编号和价格
if (ListInsert(L, ps, e) == OK)
{
cout << "插入成功!\n";
}
else
cout << "插入失败!\n";
break;
case 6:
cout << "请输入要删除的元素的位置\n";
cin >> ps;
ListDelete(L, ps);
break;
case 7: // 归并
initList(A); // 调用初始化函数
initList(B);
cout << "请输入要与L归并的顺序表A\n";
cout << "请输入图书的个数："; // 提示用户输入书籍数量
cin >> count; // 读取书籍数量
cout << "请输入图书的信息（ISBN编号 价格）：\n"; // 提示用户输入书籍信息
for (i = 0; i < count; i++) // 循环输入每本书籍的信息
cin >> A.elem[i].id >> A.elem[i].price; // 输入书籍的ISBN编号和价格
A.length = count;
if (MergeList(L, A, B) == OK)
{
AssignList(L, B); // 将归并后的B赋给L
cout << "归并成功，并将B的值赋给L!\n";
}
else
{
cout << "归并失败!\n";
}
break;
case 8: // 输出
cout << "输出顺序表内容：\n"; // 提示即将输出顺序表内容
for (i = 0; i < L.length; i++) // 遍历顺序表中的每本书
cout << left << setw(15) << L.elem[i].id << "\t" << left << setw(5) << L.elem[i].price << endl; // 输出每本书的ISBN编号和价格，格式化对齐
break;
case 9:
ClearList(L);
if (ClearList(L) == OK)
{
cout << "清空顺序表成功\n";
}
else
cout << "清楚数据成功";
}
}
return 0; // 程序正常结束
}
实验2代码（链式存储结构）
#include <iostream> //输入输出流头文件
#include <fstream> //文件操作头文件
#include <string> //字符串操作头文件
#include <iomanip> //输入输出操纵运算头文件
using namespace std; // 调用命名空间std中所有标识符
// 预定义常量及预定义类型
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status; // Status 是函数返回值类型，其值是函数结果状态代码。
// 表示部分：
typedef struct LNode
{
int data; // 结点的数据域
struct LNode *next; // 结点的指针域
} LNode, *LinkList; // LinkList为指向结构体LNode的指针类型
// 实现部分：
// 1.初始化
Status InitList_L(LinkList &L)
{
// 构造一个空的单链表L
L = new LNode; // 生成新结点作为头结点，用头指针L指向头结点
L->next = NULL; // 头结点的指针域置空
return OK;
}
// 2.头插法创建链表
void CreateList_H(LinkList &L, int n)
{ // 逆位序输入n个元素的值，建立到头结点的单链表L
LinkList p;
// LNode *p;
for (int i = 0; i < n; ++i)
{
p = new LNode; // 生成新结点*p
cout << "Please input the data：" << i + 1 << endl;
cin >> p->data; // 输入元素值赋给新结点*p的数据域
p->next = L->next;
L->next = p; // 将新结点*p插入到头结点之后
}
} // CreateList_H
// 3.尾插法创建链表
int CreateList_T(LinkList &L, int n)
{
LNode *p, *tail = L; // 尾指针
for (int i = 0; i < n; i++)
{
p = new LNode;
cout << "请输入数据：" << i + 1 << ": ";
cin >> p->data;
p->next = NULL;
tail->next = p; // 将新节点加入尾部
tail = p; // 更新尾指针
}
return OK;
}
// 4. 取值（获取链表中的第i个元素）
Status GetElem(LinkList L, int i, int &e)
{
LNode *p = L->next; // 指向第一个节点
int j = 1;
while (p && j < i) // 查找第i个节点
{
p = p->next;
j++;
}
if (!p || j > i)
return ERROR; // 第i个元素不存在
e = p->data; // 取出元素
return OK;
}
// 5.查找链表中指定元素的位置
Status LocateElem(LinkList L, int e)
{
LNode *p = L->next; // 指向第一个节点
int j = 1;
while (p)
{
if (p->data == e) // 如果找到匹配的元素
return j;
p = p->next;
j++;
}
return ERROR; // 未找到，返回0
}
//6.插入
Status ListInsert_L(LinkList &L, int i, int e)
{ // 在带头结点的单链线性表L的第i个元素之前插入元素e
LinkList p, s;
p = L;
int j = 0;
while (p && j < i - 1)
{ // 寻找第i-1个结点
p = p->next;
++j;
}
if (!p || j > i - 1)
return ERROR; // i小于1或者大于表长
s = (LinkList)malloc(sizeof(LNode)); // 生成新结点
s->data = e;
s->next = p->next; // 插入L中
p->next = s;
return OK;
} // LinstInsert_L
//7. 删除元素
Status ListDelete(LinkList &L, int i)
{
LNode *p = L; // 指向头节点
int j = 0;
while (p->next && j < i - 1) // 查找第i-1个节点
{
p = p->next;
j++;
}
if (!(p->next) || j > i - 1)
return ERROR; // 删除位置不合法
LNode *q = p->next; // 要删除的节点
p->next = q->next; // 将q节点从链表中断开
delete q; // 释放q节点的内存
return OK;
}
// 8.遍历
void TraverseList_L(LinkList L)
{
LNode *p;
p = L->next;
while (p)
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
}
//9.归并
Status MergeList_L(LinkList La, LinkList Lb, LinkList &Lc)
{
// 已知单链线性表La和Lb的元素按值非递减排列。
// 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
LinkList pa, pb, pc;
pa = La->next;
pb = Lb->next;
Lc = pc = La; // 用La的头结点作为Lc的头结点
while (pa && pb)
{
if (pa->data <= pb->data)
{
pc->next = pa;
pc = pa;
pa = pa->next;
}
else
{
pc->next = pb;
pc = pb;
pb = pb->next;
}
}
pc->next = pa ? pa : pb; // 插入剩余段
free(Lb); // 释放Lb的头结点
return OK;
} // MergeList_L
// 清空链表
Status AssignList(LinkList &L)
{
LNode *p = L->next;
while (p)
{
LNode *temp = p;
p = p->next;
delete temp; // 释放节点内存
}
L->next = NULL; // 重新初始化链表为空
cout << "链表已清空！\n";
return OK;
}
void showMenu()
{
cout << "****************************\n";
cout << "**** 1. 初始化 ****\n";
cout << "**** 2. 头插法创建 ****\n";
cout << "**** 3. 尾插法创建 ****\n";
cout << "**** 4. 取值 ****\n";
cout << "**** 5. 查找 ****\n";
cout << "**** 6. 插入 ****\n";
cout << "**** 7. 删除 ****\n";
cout << "**** 8. 遍历 ****\n";
cout << "**** 9. 归并 ****\n";
cout << "**** 0. 退出 ****\n";
cout << "****************************\n";
}
int main()
{
LinkList L,La,Lb;
int n,ps,count1,count2,i,i1,i2,e;
int choose = -1;
showMenu();
while (choose != 0)
{
cout << "Please select（0-9）:";
cin >> choose;
switch (choose)
{
case 1: // 1.初始化
InitList_L(L);
cout << "Init successfully：\n";
break;
case 2: // 2.头插法创建单链表
cout << "Please input the number of LNode：";
cin >> n;
CreateList_H(L, n);
break;
case 3: // 3.尾插法创建单链表
cout << "Please input the number of LNode：";
cin >> n;
CreateList_T(L, n);
break;
case 4: // 4.取值
cout << "请输入位置：";
cin >> i ; // 读取位置
GetElem(L, i, e); // 调用取值函数
cout << e << endl;
break;
case 5: // 5.查找
cout << "请输入元素："; // 提示用户输入查找
cin >> e; // 读取
cout << LocateElem(L, e) << endl; // 调用查找函数并输出结果
break;
case 6: // 6.插入
cout << "请输入要插入的位置\n";
cin >> ps; // 读取插入位置
cout << "请输入信息："; // 提示用户输入书籍信息
cin >> e; // 读取
if (ListInsert_L(L, ps, e) == OK)
{
cout << "插入成功!\n";
}
else
cout << "插入失败!\n";
break;
case 7: // 7.删除
cout << "请输入要删除的元素的位置\n";
cin >> ps;
ListDelete(L, ps);
break;
case 8: // 8.遍历
TraverseList_L(L);
break;
case 9: // 9.归并
InitList_L(La); // 初始化La
InitList_L(Lb); // 初始化Lb
cout << "请输入La链表的元素个数：";
cin >> count1;
cout << "请输入La链表的元素：\n";
CreateList_T(La, count1); // 使用尾插法创建La链表
cout << "请输入Lb链表的元素个数：";
cin >> count2;
cout << "请输入Lb链表的元素：\n";
CreateList_T(Lb, count2); // 使用尾插法创建Lb链表
// 合并两个链表，Lc 存储合并结果
if (MergeList_L(La, Lb, L) == OK)
{
cout << "归并成功，结果链表为：\n";
TraverseList_L(L); // 遍历输出归并后的结果链表
}
else
{
cout << "归并失败！\n";
}
break;
}
}
return 0;
}五、实验结果
实验1结果
实验2结果
（今日分享暂时到此为止啦！为不断努力的自己鼓鼓掌吧🥳。今日文案分享：心平能愈三千疾。）
![[Docker#2] 发展历史 | Namespace环境隔离 | Cgroup资源控制](https://img-blog.csdnimg.cn/img_convert/837c5d294b56fc6fbf49be193fed23ff.png)
![[每周一更]-(第122期)：模拟面试｜数据库面试思路解析](https://i-blog.csdnimg.cn/direct/098c243aa4f046adafc70b77c0b02667.jpeg#pic_center)
