数据结构课程设计 仓储管理系统
仓储管理系统
【基本功能】
把货品信息表抽象成一个线性表，货品信息（包括ID、货品名、定价、数量等）作为线性表的一个元素，实现：按ID、货品名分别查找某货品信息（包括ID、货品名、定价、数量等）；收录货品（如果货品在帐中已有，则只将总库存量增加。否则插入新增信息）；售出货品（如果帐中还有存货，则只将总库存量减少。如果库存为0，则提示售出失败）；清除货品（删除该货品信息）、修改货品（ID、货品名和单价）；排序（按定价排序--采用冒泡排序、按数量排序--采用快排）等功能。
【基本要求】
（1）分别采用单链表和顺序表实现相应功能。
（2）编写一个测试主函数，测试所实现的功能。
课程设计任务1
该程序实现了一个简单的商品库存管理系统，能够收录、删除、修改、查找、售出货品，并支持按定价和数量排序显示货品信息。
在程序中，使用了结构体定义了货品信息的数据结构，使用了动态数组来存储不定数量的货品信息。程序中还提供了扩容线性表的功能，以便存储更多的货品信息。
在菜单循环中，通过用户输入选择相应的操作。其中，插入和修改操作需要用户输入货品ID、名称、价格和数量；删除和按ID查找操作需要用户输入货品ID；按名称查找操作需要用户输入货品名称；售出操作需要用户输入货品ID。而排序和显示操作直接调用对应的函数即可。
需要注意的是，在fgets()函数读取字符串时，末尾可能会包含换行符，需要用字符串处理函数去掉。另外，在使用realloc()函数重新分配内存空间时，需要判断是否分配成功，否则会返回NULL，程序需要进行异常处理。
解释每一部分：
首先是定义了一个货品信息的结构体类型 `Product`，它包含了四个属性：`id`（整数类型）、`name`（字符数组类型，最大长度为50）、`price`（浮点数类型）和 `quantity`（整数类型）。这个结构体用于表示一个货品的详细信息。
接下来是定义了线性表的结构体类型 `List`。它包含了三个成员变量：`data`（指向 `Product` 结构体的指针）、`length`（表示当前存储的货品信息数量的整数）和 `capacity`（表示数组容量的整数）。`data` 指针将用于动态分配内存来存储货品信息数组。
`initList` 函数用于初始化线性表。它接受一个指向 `List` 结构体的指针作为参数，通过调用 `malloc` 分配了一个大小为 `sizeof(Product) * 10` 的内存块，并将其地址赋值给 `data` 指针。这样就创建了一个能够存储 10 个 `Product` 结构体的数组。同时，`length` 和 `capacity` 被初始化为 0 和 10，表示当前线性表中没有保存任何货品信息，但有足够的容量来存储。
`expandList` 函数用于扩容线性表。它接受一个指向 `List` 结构体的指针作为参数。当线性表中的存储空间不足时，即 `length` 等于 `capacity` 时，它会调用 `realloc` 函数重新分配一个更大的内存块。新的内存块的大小是原来的容量加上 10 个 `Product` 结构体的大小，然后更新 `data` 指针和 `capacity` 的值。这样就实现了线性表的扩容操作。
通过上述代码，我们定义了一个基本的线性表数据结构，其中可以存储和管理多个货品的详细信息。你可以使用 `initList` 函数初始化线性表，并通过 `expandList` 函数在需要时动态地扩展存储空间。这个数据结构为进一步实现增删改查等功能提供了基础。
```c
#include
#include
#include
```
这些是程序所需的头文件，包括标准输入输出和字符串处理的函数。
```c
typedef struct {
int id;
char name[50];
float price;
int quantity;
} Product;
```
这是一个货品信息的结构体，包含了货品的ID、名称、价格和数量等属性。
```c
typedef struct {
Product* data;
int length;
int capacity;
} List;
```
这是线性表的结构体，包含了一个指向存储货品信息的数组的指针、当前存储的货品信息数量和数组的容量。
```c
void initList(List* list) {
list->data = (Product*)malloc(sizeof(Product) * 10);
list->length = 0;
list->capacity = 10;
}
```
这个函数用于初始化线性表。它分配了一个初始容量为10的数组来存储货品信息，并将长度和容量都设置为0。
它会将原来的数组指针传递给realloc函数，同时计算新的容量并分配足够的内存空间。然后，它更新线性表的容量属性，以便反映新的容量大小。这样做的目的是在需要存储更多货品信息时，可以动态地扩展线性表的容量，避免因为容量不足而导致无法插入新的货品信息。在上面的代码中，realloc函数用于扩展线性表的容量。它接受线性表原来的数据指针作为第一个参数，计算新的容量并分配足够的内存空间，然后返回指向重新分配后的内存块的指针。通过将这个指针赋值给线性表的数据属性，就实现了线性表容量的扩展。
realloc是C语言中的一个函数，用于重新分配内存空间的大小。它接受两个参数：原始的内存指针和新的内存大小。
具体来说，realloc函数会根据新的内存大小重新分配内存，并将原始的内存内容复制到新的内存块中。如果新的内存大小大于原始内存大小，那么额外的内存空间将被初始化为未定义的值。如果新的内存大小小于原始内存大小，那么超出新大小的部分将被丢弃。
realloc函数的返回值是指向重新分配后的内存块的指针。如果内存分配成功，返回的指针与原始的内存指针相同；如果内存分配失败，返回NULL指针。
```c
void expandList(List* list) {
list->data = (Product*)realloc(list->data, sizeof(Product) * (list->capacity + 10));
list->capacity += 10;
}
```
这个函数用于扩容线性表。当存储空间不足时，它会重新分配更大的存储空间，并更新容量。
```c
void insertProduct(List* list, Product product) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == product.id) {
list->data[i].quantity += product.quantity;
return;
}
}
if (list->length >= list->capacity) {
expandList(list);
}
list->data[list->length++] = product;
}
```
这个函数用于插入货品信息。它首先检查要插入的货品是否已经存在于列表中，如果存在则增加其数量；如果不存在，则将新的货品信息插入到列表末尾。当存储空间不足时，会自动扩容。
```c
void deleteProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
list->data[i] = list->data[list->length - 1];
list->length--;
return;
}
}
printf("货品不存在\n");
}
```099
这个函数用于删除指定ID的货品信息。它会遍历整个列表，找到与给定ID匹配的货品信息，并将最后一个货品信息覆盖到要删除的位置上，然后更新长度。
```c
void modifyProduct(List* list, int id, char name[], float price) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
strcpy(list->data[i].name, name);
list->data[i].price = price;
return;
}
}
printf("货品不存在\n");
}
```
`strcpy`是C语言中的一个字符串操作函数，用于将一个字符串复制到另一个字符串中。它接受两个参数：目标字符串和源字符串。
具体来说，`strcpy`函数会从源字符串的起始位置开始，逐个字符地复制到目标字符串中，直到遇到字符串结束符'\0'。复制完成后，目标字符串将包含与源字符串相同的内容。
函数原型如下：
```c
char* strcpy(char* dest, const char* src);
```
其中，`dest`表示目标字符串，`src`表示源字符串。函数返回一个指向目标字符串的指针。
需要注意的是，为了保证目标字符串足够大，能够存储源字符串的内容，建议在使用`strcpy`时先确保目标字符串的内存空间足够
这个函数用于修改指定ID的货品信息。它会遍历整个列表，找到与给定ID匹配的货品信息，并将名称和价格进行修改。
```c
void searchById(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
```
这个函数用于按ID查找货品信息。它会遍历整个列表，找到与给定ID匹配的货品信息，并打印出来。
```c
void searchByName(List* list, char name[]) {
int i;
for (i = 0; i < list->length; i++) {
if (strcmp(list->data[i].name, name) == 0) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
```
这个函数用于按货品名查找货品信息。它会遍历整个列表，找到与给定名称匹配的货品信息，并打印出来。
```c
void sellProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
if (list->data[i].quantity >
```c
#include
#include
#include
```
这些是程序所需的头文件，包括标准输入输出和字符串处理的函数。
`stdlib.h`是C语言标准库中的一个头文件，提供了一些常用的函数和类型定义，涵盖了内存管理、随机数生成、字符串转换等功能。
这个头文件包含了以下常用函数的声明：
- `malloc`：用于动态分配内存空间。
- `calloc`：用于动态分配并初始化内存空间。
- `realloc`：用于重新分配已分配内存空间的大小。
- `free`：用于释放之前通过`malloc`、`calloc`或`realloc`函数分配的内存空间。
- `exit`：终止程序的执行。
- `rand`：生成伪随机数。
- `srand`：设置`rand`函数的随机数种子。
- `abs`：取整数的绝对值。
- `atoi`、`atol`、`atof`：将字符串转换为整数、长整数、浮点数。
- `system`：调用系统命令。
除了上述函数声明外，`stdlib.h`还定义了一些常用的数据类型，如`size_t`、`div_t`、`ldiv_t`、`lldiv_t`等。
需要注意的是，在使用这些函数之前，需要包含`stdlib.h`头文件，以便编译器正确识别函数声明和类型定义。
以下是一个使用`stdlib.h`头文件的示例代码：
```c
#include
#include
int main() {
int* ptr = (int*)malloc(sizeof(int)); // 动态分配一个int类型的内存空间
if (ptr == NULL) {
printf("内存分配失败");
return 1;
}
*ptr = 42; // 在分配的内存空间中存储数据
printf("动态分配的内存空间中的值为：%d\n", *ptr);
free(ptr); // 释放内存空间
return 0;
}
```
在上面的代码中，我们通过`malloc`函数动态分配了一个`int`类型的内存空间，然后将值42存储在该内存空间中。最后，使用`free`函数释放了该内存空间。
首先是主函数，这个函数负责整个程序的流程控制，根据用户输入的选项，调用不同的函数实现不同的操作。在每次输入完选项后，使用`getchar()`函数读取输入缓冲区中的换行符，避免在后续的输入操作中出现问题。
```c
int main() {
List list;
initList(&list);
// 菜单循环
while (1) {
printf("\n===============\n");
printf("1. 收录货品\n");
printf("2. 删除货品\n");
printf("3. 修改货品\n");
printf("4. 按ID查找货品\n");
printf("5. 按货品名查找货品\n");
printf("6. 售出货品\n");
printf("7. 按定价排序\n");
printf("8. 按数量排序\n");
printf("9. 显示货品信息\n");
printf("0. 退出\n");
printf("===============\n");
printf("请选择操作：");
int choice;
scanf("%d", &choice);
getchar(); // 处理输入缓冲区的换行符
if (choice == 1) {
// ...
}
else if (choice == 2) {
// ...
}
// ...
else if (choice == 0) {
break;
}
else {
printf("无效的选择\n");
}
}
free(list.data); // 释放内存
return 0;
}
```
接下来是链表的定义和初始化函数。链表中每个节点包含一个`Product`结构体，记录货品的ID、名称、定价和数量等信息。`List`结构体则包含了链表的头指针和长度信息。
```c
typedef struct Product {
int id; // 货品ID
char name[50]; // 货品名
float price; // 定价
int quantity; // 数量
} Product;
typedef struct List {
Product* data; // 数据数组
int length; // 当前数据个数
} List;
// 初始化链表，分配一个空间并将其初始化为空表
void initList(List* list) {
list->data = (Product*)malloc(sizeof(Product) * MAX_SIZE);
list->length = 0;
}
```
然后是添加货品、删除货品和修改货品的函数实现。这些函数都需要遍历链表查找相应的节点，然后修改其值或者删除该节点，并调整链表的结构。
```c
// 添加货品函数
void insertProduct(List* list, Product product) {
if (list->length >= MAX_SIZE) {
printf("超出最大容量，无法添加\n");
return;
}
// 在尾部插入新节点
list->data[list->length] = product;
list->length++;
}
// 删除货品函数
void deleteProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
// 将后面的元素向前移动覆盖该元素
int j;
for (j = i; j < list->length - 1; j++) {
list->data[j] = list->data[j + 1];
}
list->length--;
printf("删除成功\n");
return;
}
}
printf("货品不存在\n");
}
// 修改货品函数
void modifyProduct(List* list, int id, char* name, float price) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
strcpy(list->data[i].name, name);
list->data[i].price = price;
printf("修改成功\n");
return;
}
}
printf("货品不存在\n");
}
```
下面是按ID和按名称查找货品的函数。这些函数也需要遍历链表查找相应的节点，并返回查询结果。
```c
// 按ID查找货品函数
void searchById(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
// 按名称查找货品函数
void searchByName(List* list, char* name) {
int i;
for (i = 0; i < list->length; i++) {
if (strcmp(list->data[i].name, name) == 0) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
```
接下来是售出货品的函数。该函数需要遍历链表查找相应的节点，并修改其数量信息。
```c
// 售出货品函数
void sellProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
if (list->data[i].quantity > 0) {
list->data[i].quantity--;
printf("售出成功\n");
}
else {
printf("售出失败，库存为0\n");
}
return;
}
}
printf("货品不存在\n");
}
```
然后是按定价排序和按数量排序的函数实现。按定价排序使用冒泡排序算法，按数量排序使用快速排序算法。这些排序算法都是经典的算法，不再赘述。
```c
// 按定价排序函数（冒泡排序）
void sortByPrice(List* list) {
int i, j;
for (i = 0; i < list->length - 1; i++) {
for (j = 0; j < list->length - i - 1; j++) {
if (list->data[j].price > list->data[j + 1].price) {
// 交换元素
Product temp = list->data[j];
list->data[j] = list->data[j + 1];
list->data[j + 1] = temp;
}
}
}
}
这个函数是按照货品的定价进行排序的。具体来说，它使用冒泡排序算法，从头到尾遍历链表，比较相邻的两个节点的定价大小，如果前面的节点定价大于后面的节点，则交换这两个节点的值。这样一轮下来，最大的定价就会被移动到链表的末尾。接着再从头开始进行下一轮比较，依次类推，直到整个链表都排好序为止。
这个函数的输入参数是一个指向List结构体的指针，表示要对哪个链表进行排序。函数内部使用指向Product结构体的指针来访问每个节点的信息。
冒泡排序是一种简单直观的排序算法，它重复地遍历待排序的元素序列，比较相邻两个元素的大小，并按照指定的顺序交换它们，从而将最大（或最小）的元素逐渐"浮"到序列的末尾。冒泡排序的基本思想是通过相邻元素之间的比较和交换，使得每一轮遍历都能找到当前未排序部分的最大（或最小）元素。
在这个具体的按定价排序函数中，它使用了两层循环来实现冒泡排序。外层循环控制需要进行比较的轮数，内层循环则负责每一轮的比较和交换操作。
首先，外层循环从第一个元素开始，一直遍历到倒数第二个元素，即`list->length - 1`。这是因为在每一轮比较中，最后一个元素已经处于正确的位置上，无需再进行比较。
接着，内层循环从第一个元素开始，一直遍历到当前未排序部分的最后一个元素。在每一轮内层循环中，它会比较相邻的两个元素的定价大小，如果前面的元素的定价大于后面的元素，则交换这两个元素的值。通过这样的比较和交换操作，每一轮都能将当前未排序部分的最大定价元素"浮"到序列的末尾。
重复进行外层循环和内层循环，直至所有元素都排好序为止。
总体来说，冒泡排序的时间复杂度是O(n^2)，其中n是待排序序列的长度。在最坏情况下，需要进行n-1轮比较，每轮比较需要遍历n-i次（i为已经排好序的元素个数），因此总的比较次数是n(n-1)/2。对于较小规模的序列，冒泡排序是一种简单实用的排序算法，但对于大规模数据来说效率较低。
// 按数量排序函数（快速排序）
void quickSortByQuantity(Product* data, int left, int right) {
if (left >= right) {
return;
}
int i = left;
int j = right;
Product pivot = data[left];
while (i < j) {
while (i < j && data[j].quantity >= pivot.quantity) {
j--;
}
data[i] = data[j];
while (i < j && data[i].quantity <= pivot.quantity) {
i++;
}
data[j] = data[i];
}
data[i] = pivot;
quickSortByQuantity(data, left, i - 1);
quickSortByQuantity(data, i + 1, right);
}
```
这段代码实现了按照数量进行排序的快速排序算法。
快速排序是一种高效的排序算法，它采用分治的思想来进行排序。具体实现如下：
1. 首先，判断左边界 `left` 是否大于等于右边界 `right`，如果是，则表示已经排好序或者只有一个元素，直接返回。
2. 然后，选择数组中的一个基准元素（pivot），这里选择第一个元素 `data[left]` 作为基准元素。
3. 接着，设置两个指针 `i` 和 `j`，分别指向左右边界。
4. 进入循环，首先从右边开始，找到第一个比基准元素小的元素，将其移动到左边，并将 `j` 向左移动一位。
5. 接着，从左边开始，找到第一个比基准元素大的元素，将其移动到右边，并将 `i` 向右移动一位。
6. 重复步骤4和步骤5，直到 `i` 和 `j` 相遇。
7. 将基准元素放到相遇的位置，此时基准元素左边的元素都比它小，右边的元素都比它大。
8. 对基准元素左右两边的子数组分别进行递归调用快速排序函数，分别排序左边和右边的部分。
9. 递归结束后，数组就排好序了。
这样，通过不断地将基准元素放到正确的位置，最终实现了按照数量进行排序。快速排序的平均时间复杂度为 O(nlogn)，但在最坏情况下会退化到 O(n^2)。然而，快速排序通常比其他排序算法更快，并且在实践中表现良好。
最后是显示货品信息的函数实现。该函数遍历链表，按照指定的格式输出每个节点的信息。
```c
// 显示货品信息函数
void showProducts(List* list) {
int i;
for (i = 0; i < list->length; i++) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
}
}
```
以上就是整个程序的实现。通过这个简单的货物管理系统，我们可以了解到链表的实现和操作，以及常见的排序算法的实现方法。
源代码：
#include
#include
#include
// 货品信息结构体
typedef struct {
int id; // 货品ID
char name[50]; // 货品名称
float price; // 货品价格
int quantity; // 货品数量
} Product;
// 线性表结构体
typedef struct {
Product* data; // 指向存储货品信息的数组的指针
int length; // 当前存储的货品信息数量
int capacity; // 数组的容量
} List;
// 初始化线性表
void initList(List* list) {
list->data = (Product*)malloc(sizeof(Product) * 10); // 初始分配存储空间
list->length = 0; // 初始长度为0
list->capacity = 10; // 初始容量为10
}
// 扩容线性表
void expandList(List* list) {
list->data = (Product*)realloc(list->data, sizeof(Product) * (list->capacity + 10)); // 重新分配更大的存储空间
list->capacity += 10; // 更新容量
}
// 插入货品信息
void insertProduct(List* list, Product product) {
int i;
// 判断货品是否已存在
for (i = 0; i < list->length; i++) {
if (list->data[i].id == product.id) {
// 货品已存在，增加库存量
list->data[i].quantity += product.quantity;
return;
}
}
// 货品不存在，插入新增信息
if (list->length >= list->capacity) {
expandList(list); // 如果存储空间不足，扩容
}
list->data[list->length++] = product; // 插入新的货品信息
}
// 删除货品信息
void deleteProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
// 将最后一个元素覆盖要删除的元素
list->data[i] = list->data[list->length - 1];
list->length--; // 更新长度
return;
}
}
printf("货品不存在\n");
}
// 修改货品信息
void modifyProduct(List* list, int id, char name[], float price) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
strcpy(list->data[i].name, name); // 修改名称
list->data[i].price = price; // 修改价格
return;
}
}
printf("货品不存在\n");
}
// 按ID查找货品信息
void searchById(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
// 按货品名查找货品信息
void searchByName(List* list, char name[]) {
int i;
for (i = 0; i < list->length; i++) {
if (strcmp(list->data[i].name, name) == 0) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
return;
}
}
printf("货品不存在\n");
}
// 售出货品
void sellProduct(List* list, int id) {
int i;
for (i = 0; i < list->length; i++) {
if (list->data[i].id == id) {
if (list->data[i].quantity > 0) {
list->data[i].quantity--;
printf("售出成功\n");
}
else {
printf("售出失败，库存为0\n");
}
return;
}
}
printf("货品不存在\n");
}
// 按定价排序（冒泡排序）
void sortByPrice(List* list) {
int i, j;
for (i = 0; i < list->length - 1; i++) {
for (j = 0; j < list->length - i - 1; j++) {
if (list->data[j].price > list->data[j + 1].price) {
// 交换元素
Product temp = list->data[j];
list->data[j] = list->data[j + 1];
list->data[j + 1] = temp;
}
}
}
}
// 按数量排序（快速排序）
void quickSortByQuantity(Product* data, int left, int right) {
if (left >= right) {
return;
}
int i = left;
int j = right;
Product pivot = data[left];
while (i < j) {
while (i < j && data[j].quantity >= pivot.quantity) {
j--;
}
data[i] = data[j];
while (i < j && data[i].quantity <= pivot.quantity) {
i++;
}
data[j] = data[i];
}
data[i] = pivot;
quickSortByQuantity(data, left, i - 1);
quickSortByQuantity(data, i + 1, right);
}
// 显示货品信息
void showProducts(List* list) {
int i;
for (i = 0; i < list->length; i++) {
printf("ID: %d, 货品名: %s, 定价: %.2f, 数量: %d\n", list->data[i].id, list->data[i].name, list->data[i].price,
list->data[i].quantity);
}
}
int main() {
List list;
initList(&list);
// 菜单循环
while (1) {
printf("\n===============\n");
printf("1. 收录货品\n");
printf("2. 删除货品\n");
printf("3. 修改货品\n");
printf("4. 按ID查找货品\n");
printf("5. 按货品名查找货品\n");
printf("6. 售出货品\n");
printf("7. 按定价排序\n");
printf("8. 按数量排序\n");
printf("9. 显示货品信息\n");
printf("0. 退出\n");
printf("===============\n");
printf("请选择操作：");
int choice;
scanf("%d", &choice);
getchar(); // 处理输入缓冲区的换行符
if (choice == 1) {
Product product;
printf("请输入货品ID：");
scanf("%d", &product.id);
getchar();
printf("请输入货品名：");
fgets(product.name, 50, stdin);
product.name[strlen(product.name) - 1] = '\0'; // 去掉末尾的换行符
printf("请输入货品定价：");
scanf("%f", &product.price);
printf("请输入货品数量：");
scanf("%d", &product.quantity);
insertProduct(&list, product);
printf("收录成功\n");
}
else if (choice == 2) {
int id;
printf("请输入要删除的货品ID：");
scanf("%d", &id);
deleteProduct(&list, id);
}
else if (choice == 3) {
int id;
printf("请输入要修改的货品ID：");
scanf("%d", &id);
getchar();
char name[50];
printf("请输入新的货品名：");
fgets(name, 50, stdin);
name[strlen(name) - 1] = '\0'; // 去掉末尾的换行符
float price;
printf("请输入新的货品定价：");
scanf("%f", &price);
modifyProduct(&list, id, name, price);
}
else if (choice == 4) {
int id;
printf("请输入要查找的货品ID：");
scanf("%d", &id);
searchById(&list, id);
}
else if (choice == 5) {
char name[50];
printf("请输入要查找的货品名：");
getchar();
fgets(name, 50, stdin);
name[strlen(name) - 1] = '\0'; // 去掉末尾的换行符
searchByName(&list, name);
}
else if (choice == 6) {
int id;
printf("请输入要售出的货品ID：");
scanf("%d", &id);
sellProduct(&list, id);
}
else if (choice == 7) {
sortByPrice(&list);
printf("按定价排序完成\n");
}
else if (choice == 8) {
quickSortByQuantity(list.data, 0, list.length - 1);
printf("按数量排序完成\n");
}
else if (choice == 9) {
showProducts(&list);
}
else if (choice == 0) {
break;
}
else {
printf("无效的选择\n");
}
}
free(list.data); // 释放内存
return 0;
}