【基本功能】
把货品信息表抽象成一个线性表,货品信息(包括ID、货品名、定价、数量等)作为线性表的一个元素,实现:按ID、货品名分别查找某货品信息(包括ID、货品名、定价、数量等);收录货品(如果货品在帐中已有,则只将总库存量增加。否则插入新增信息);售出货品(如果帐中还有存货,则只将总库存量减少。如果库存为0,则提示售出失败);清除货品(删除该货品信息)、修改货品(ID、货品名和单价);排序(按定价排序--采用冒泡排序、按数量排序--采用快排)等功能。
【基本要求】
(1)分别采用单链表和顺序表实现相应功能。
(2)编写一个测试主函数,测试所实现的功能。
该程序实现了一个简单的商品库存管理系统,能够收录、删除、修改、查找、售出货品,并支持按定价和数量排序显示货品信息。
在程序中,使用了结构体定义了货品信息的数据结构,使用了动态数组来存储不定数量的货品信息。程序中还提供了扩容线性表的功能,以便存储更多的货品信息。
在菜单循环中,通过用户输入选择相应的操作。其中,插入和修改操作需要用户输入货品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;
}