顺序表的定义及其特点
定义
用顺序存储方法存储的线性表，即顺序表。所谓顺序存储方法就是把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
特点
1.数据元素顺序存储:顺序表中的数据元素按照一定的顺序依次存放，每个元素都有一个与之关联的索引，可以用于快速访问。
2.访问速度快:由于顺序表的数据元素是连续存储的，因此可以通过下标直接访问元素。
3.插入和删除操作不方便:如果需要在顺序表的中间插入或删除元素，需要将后续元素依次向后或向前移动。
4.存储密度高:顺序表中的每个节点只存储数据元素本身，没有额外的空间存储指针，因此相较而言，顺序表的存储密度较高。
5.拓展容量不方便:顺序表一-旦确定了长度，就不能再改变，即使采用动态分配的方式实现，拓展长度的时间复杂度也比较高。
顺序表的运算（概述）
初始化：创建一个空的顺序表。
插入元素：在指定位置插入一个元素。
删除元素：删除指定位置的元素。
判断是否为空：判断顺序表是否为空。
判断是否已满：判断顺序表是否已满。
打印顺序表：按顺序打印顺序表中的元素。
顺序表的实现
顺序表的创建和初始化
根据提示，输入顺序表的长度和元素，并根据所输入的数据来创建和初始化一个顺序表。输入的数据会存储在顺序表的数据数组中，并且顺序表的长度为初始化输入的长度，如果输入的长度超过了最大允许值或炜负数，程序会报告创建失败。
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 定义顺序表的结构体
typedef struct {
int data[MAX_SIZE]; // 存储元素的数组
int length; // 当前顺序表的长度
} ArrayList;
// 初始化顺序表
void initArrayList(ArrayList *list) {
list->length = 0; // 初始长度为0
}
int main() {
ArrayList myList;
initArrayList(&myList);
int n; // 顺序表的长度
printf("请输入顺序表的长度：");
scanf("%d", &n);
if (n <= MAX_SIZE && n >= 0) {
printf("请输入 %d 个元素，以空格分隔：\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &myList.data[i]);
}
myList.length = n; // 设置顺序表的长度
printf("顺序表创建成功，长度为 %d。\n", n);
} else {
printf("输入的长度无效，顺序表创建失败。\n");
}
return 0;
}
运行结果：
顺序表的插入
在顺序表中插入一个元素，需要保证插入位置及之后的所有元素向后移动一个位置，然后将新元素放在指定位置。
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 定义顺序表的结构体
typedef struct {
int data[MAX_SIZE]; // 存储元素的数组
int length; // 当前顺序表的长度
} ArrayList;
// 初始化顺序表
void initArrayList(ArrayList *list) {
list->length = 0; // 初始长度为0
}
// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
return list->length == 0;
}
// 判断顺序表是否已满
int isFull(ArrayList *list) {
return list->length == MAX_SIZE;
}
// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
if (!isFull(list)) {
list->data[list->length++] = element;
} else {
printf("顺序表已满，无法添加元素。\n");
}
}
// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
if (index < 0 || index > list->length) {
printf("插入位置无效。\n");
return;
}
if (!isFull(list)) {
for (int i = list->length; i > index; i--) {
list->data[i] = list->data[i - 1];
}
list->data[index] = element;
list->length++;
printf("元素 %d 已插入到位置 %d。\n", element, index);
} else {
printf("顺序表已满，无法插入元素。\n");
}
}
int main() {
ArrayList myList;
initArrayList(&myList);
int n; // 顺序表的长度
printf("请输入顺序表的长度：");
scanf("%d", &n);
if (n <= MAX_SIZE && n >= 0) {
printf("请输入 %d 个元素，以空格分隔：\n", n);
for (int i = 0; i < n; i++) {
int element;
scanf("%d", &element);
append(&myList, element);
}
printf("顺序表创建成功，长度为 %d。\n", n);
} else {
printf("输入的长度无效，顺序表创建失败。\n");
return 1; // 退出程序，表示创建失败
}
int choice;
while (1) {
printf("\n顺序表操作选项：\n");
printf("1. 插入元素\n");
printf("2. 退出\n");
printf("请选择操作：");
scanf("%d", &choice);
switch (choice) {
case 1:
if (!isFull(&myList)) {
int index, element;
printf("请输入要插入的位置和元素（例如，位置 元素）：");
scanf("%d %d", &index, &element);
insert(&myList, index, element);
} else {
printf("顺序表已满，无法插入元素。\n");
}
break;
case 2:
printf("退出程序。\n");
exit(0);
default:
printf("无效的选项，请重新选择。\n");
break;
}
}
return 0;
}
运行结果
顺序表的删除
在顺序表中删除元素，需要将被删除元素之后的所有元素向前移动一个位置。
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 定义顺序表的结构体
typedef struct {
int data[MAX_SIZE]; // 存储元素的数组
int length; // 当前顺序表的长度
} ArrayList;
// 初始化顺序表
void initArrayList(ArrayList *list) {
list->length = 0; // 初始长度为0
}
// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
return list->length == 0;
}
// 判断顺序表是否已满
int isFull(ArrayList *list) {
return list->length == MAX_SIZE;
}
// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
if (!isFull(list)) {
list->data[list->length++] = element;
} else {
printf("顺序表已满，无法添加元素。\n");
}
}
// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
if (index < 0 || index > list->length) {
printf("插入位置无效。\n");
return;
}
if (!isFull(list)) {
for (int i = list->length; i > index; i--) {
list->data[i] = list->data[i - 1];
}
list->data[index] = element;
list->length++;
printf("元素 %d 已插入到位置 %d。\n", element, index);
} else {
printf("顺序表已满，无法插入元素。\n");
}
}
// 删除指定位置的元素
void remove(ArrayList *list, int index) {
if (index < 0 || index >= list->length) {
printf("删除位置无效。\n");
return;
}
printf("删除元素 %d 位于位置 %d。\n", list->data[index], index);
for (int i = index; i < list->length - 1; i++) {
list->data[i] = list->data[i + 1];
}
list->length--;
}
int main() {
ArrayList myList;
initArrayList(&myList);
int n; // 顺序表的长度
printf("请输入顺序表的长度：");
scanf("%d", &n);
if (n <= MAX_SIZE && n >= 0) {
printf("请输入 %d 个元素，以空格分隔：\n", n);
for (int i = 0; i < n; i++) {
int element;
scanf("%d", &element);
append(&myList, element);
}
printf("顺序表创建成功，长度为 %d。\n", n);
} else {
printf("输入的长度无效，顺序表创建失败。\n");
return 1; // 退出程序，表示创建失败
}
int choice;
while (1) {
printf("\n顺序表操作选项：\n");
printf("1. 删除元素\n");
printf("2. 退出\n");
printf("请选择操作：");
scanf("%d", &choice);
switch (choice) {
case 1:
if (!isEmpty(&myList)) {
int index;
printf("请输入要删除的位置：");
scanf("%d", &index);
remove(&myList, index);
} else {
printf("顺序表为空，无法删除元素。\n");
}
break;
case 2:
printf("退出程序。\n");
exit(0);
default:
printf("无效的选项，请重新选择。\n");
break;
}
}
return 0;
}
运行结果
获取和打印顺序表
在顺序表中查找一个元素，可以通过下标直接访问。
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 定义顺序表的结构体
typedef struct {
int data[MAX_SIZE]; // 存储元素的数组
int length; // 当前顺序表的长度
} ArrayList;
// 初始化顺序表
void initArrayList(ArrayList *list) {
list->length = 0; // 初始长度为0
}
// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
return list->length == 0;
}
// 判断顺序表是否已满
int isFull(ArrayList *list) {
return list->length == MAX_SIZE;
}
// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
if (!isFull(list)) {
list->data[list->length++] = element;
} else {
printf("顺序表已满，无法添加元素。\n");
}
}
// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
if (index < 0 || index > list->length) {
printf("插入位置无效。\n");
return;
}
if (!isFull(list)) {
for (int i = list->length; i > index; i--) {
list->data[i] = list->data[i - 1];
}
list->data[index] = element;
list->length++;
printf("元素 %d 已插入到位置 %d。\n", element, index);
} else {
printf("顺序表已满，无法插入元素。\n");
}
}
// 删除指定位置的元素
void romve(ArrayList *list, int index) {
if (index < 0 || index >= list->length) {
printf("删除位置无效。\n");
return;
}
printf("删除元素 %d 位于位置 %d。\n", list->data[index], index);
for (int i = index; i < list->length - 1; i++) {
list->data[i] = list->data[i + 1];
}
list->length--;
}
// 获取指定位置的元素
int get(ArrayList *list, int index) {
if (index < 0 || index >= list->length) {
printf("索引越界。\n");
return -1;
}
return list->data[index];
}
// 打印顺序表的所有元素
void display(ArrayList *list) {
printf("顺序表的元素：");
for (int i = 0; i < list->length; i++) {
printf("%d ", list->data[i]);
}
printf("\n");
}
int main() {
ArrayList myList;
initArrayList(&myList);
int n; // 顺序表的长度
printf("请输入顺序表的长度：");
scanf("%d", &n);
if (n <= MAX_SIZE && n >= 0) {
printf("请输入 %d 个元素，以空格分隔：\n", n);
for (int i = 0; i < n; i++) {
int element;
scanf("%d", &element);
append(&myList, element);
}
printf("顺序表创建成功，长度为 %d。\n", n);
} else {
printf("输入的长度无效，顺序表创建失败。\n");
return 1; // 退出程序，表示创建失败
}
int choice;
while (1) {
printf("\n顺序表操作选项：\n");
printf("1. 获取元素\n");
printf("2. 打印顺序表\n");
printf("3. 退出\n");
printf("请选择操作：");
scanf("%d", &choice);
switch (choice) {
case 1:
if (!isEmpty(&myList)) {
int index;
printf("请输入要获取的位置：");
scanf("%d", &index);
int element = get(&myList, index);
if (element != -1) {
printf("获取的元素：%d\n", element);
}
} else {
printf("顺序表为空，无法获取元素。\n");
}
break;
case 2:
if (!isEmpty(&myList)) {
display(&myList);
} else {
printf("顺序表为空，无法打印元素。\n");
}
break;
case 3:
printf("退出程序。\n");
exit(0);
default:
printf("无效的选项，请重新选择。\n");
break;
}
}
return 0;
}
运行结果
完整的Demo
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 定义顺序表的结构体
typedef struct {
int data[MAX_SIZE]; // 用于存储元素的数组
int length; // 当前顺序表的长度
} ArrayList;
// 初始化顺序表
void initArrayList(ArrayList *list) {
list->length = 0; // 初始长度为0
}
// 判断顺序表是否为空
int isEmpty(ArrayList *list) {
return list->length == 0;
}
// 判断顺序表是否已满
int isFull(ArrayList *list) {
return list->length == MAX_SIZE;
}
// 向顺序表末尾添加元素
void append(ArrayList *list, int element) {
if (!isFull(list)) {
list->data[list->length++] = element;
} else {
printf("顺序表已满，无法添加元素。\n");
}
}
// 在指定位置插入元素
void insert(ArrayList *list, int index, int element) {
if (index < 0 || index > list->length) {
printf("插入位置无效。\n");
return;
}
if (!isFull(list)) {
for (int i = list->length; i > index; i--) {
list->data[i] = list->data[i - 1];
}
list->data[index] = element;
list->length++;
} else {
printf("顺序表已满，无法插入元素。\n");
}
}
// 删除指定位置的元素
void remove(ArrayList *list, int index) {
if (index < 0 || index >= list->length) {
printf("删除位置无效。\n");
return;
}
for (int i = index; i < list->length - 1; i++) {
list->data[i] = list->data[i + 1];
}
list->length--;
}
// 获取指定位置的元素
int get(ArrayList *list, int index) {
if (index < 0 || index >= list->length) {
printf("索引越界。\n");
return -1;
}
return list->data[index];
}
// 打印顺序表的所有元素
void display(ArrayList *list) {
printf("顺序表的元素：");
for (int i = 0; i < list->length; i++) {
printf("%d ", list->data[i]);
}
printf("\n");
}
int main() {
ArrayList myList;
initArrayList(&myList);
int choice;
while (1) {
printf("\n顺序表操作选项：\n");
printf("1. 添加元素\n");
printf("2. 插入元素\n");
printf("3. 删除元素\n");
printf("4. 获取元素\n");
printf("5. 打印顺序表\n");
printf("6. 退出\n");
printf("请选择操作：");
scanf("%d", &choice);
switch (choice) {
case 1:
if (!isFull(&myList)) {
int element;
printf("请输入要添加的元素：");
scanf("%d", &element);
append(&myList, element);
printf("元素 %d 已添加。\n", element);
} else {
printf("顺序表已满，无法添加元素。\n");
}
break;
case 2:
if (!isFull(&myList)) {
int index, element;
printf("请输入要插入的位置和元素（例如，位置 元素）：");
scanf("%d %d", &index, &element);
insert(&myList, index, element);
printf("元素 %d 已插入到位置 %d。\n", element, index);
} else {
printf("顺序表已满，无法插入元素。\n");
}
break;
case 3:
if (!isEmpty(&myList)) {
int index;
printf("请输入要删除的位置：");
scanf("%d", &index);
remove(&myList, index);
printf("元素已删除。\n");
} else {
printf("顺序表为空，无法删除元素。\n");
}
break;
case 4:
if (!isEmpty(&myList)) {
int index;
printf("请输入要获取的位置：");
scanf("%d", &index);
int element = get(&myList, index);
if (element != -1) {
printf("获取的元素：%d\n", element);
}
} else {
printf("顺序表为空，无法获取元素。\n");
}
break;
case 5:
if (!isEmpty(&myList)) {
display(&myList);
} else {
printf("顺序表为空，无法打印元素。\n");
}
break;
case 6:
printf("退出程序。\n");
exit(0);
default:
printf("无效的选项，请重新选择。\n");
break;
}
}
return 0;
}
小结
1.优点
(1)存储空间利用率高:顺序表采用连续的存储方式，可以利用数组中未使用的空间，避免空间的浪费。
(2)随机访问速度快:顺序表中的元素可以通过下标进行随机访问，访问速度较快。
(3) 插入和删除操作方便:在顺序表中，元素的插入和删除操作只需要移动元素的位置,操作相对简单。
2.不足
(1) 动态扩展性较差:顺序表的容量是固定的，无法动态扩展，如果需要增加容量，需重新创建一个新的数组，并将原有数据复制到新数组中，这会带来定的开销。
(2)数组开销大:为了维护顺序表的顺序，需要付出一些额外的开销， 如数组初始化、扩展、缩小等。
参考文献
https://blog.csdn.net/m0_51771262/article/details/133598733?spm=1001.2014.3001.5501
百度文档
数据结构（c语言版）——主编 李刚 刘万辉
3201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
