数据结构课程设计 仓储管理系统

 仓储管理系统

【基本功能】

把货品信息表抽象成一个线性表,货品信息(包括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 <stdio.h>

#include <stdlib.h>

#include <string.h>

```

这些是程序所需的头文件,包括标准输入输出和字符串处理的函数。

```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 <stdio.h>

#include <stdlib.h>

#include <string.h>

```

这些是程序所需的头文件,包括标准输入输出和字符串处理的函数。

`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 <stdio.h>

#include <stdlib.h>

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 <stdio.h>

#include <stdlib.h>

#include <string.h>

// 货品信息结构体

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;

}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/243688.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

前台vue配置

前台 vue环境 1.傻瓜式安装node: 官网下载&#xff1a;https://nodejs.org/zh-cn/2.安装cnpm: >: npm install -g cnpm --registryhttps://registry.npm.taobao.org3.安装vue最新脚手架: >: cnpm install -g vue/cli注&#xff1a;如果2、3步报错&#xff0c;清除缓…

FastReport动态绑定数据源

先新建数据源 然后选择新建连接csv 选择好后&#xff0c;下一步完成&#xff0c;拖到自己想要的位置即可 程序里对应上相应的名称就行了 // 创建报表 Report report new Report(); report.Load(frxPath); DataTable dataTable1 new DataTable("MyDataTable");…

如何攻克钙钛矿太阳能电池电性能测试技术壁垒?

1 前言 “碳达峰、碳中和”背景下&#xff0c;发展新能源成为降低碳排放的第一驱动力。以太阳能为代表的清洁能源在市场上的占比大幅提升&#xff0c;与之对应的太阳能电池同样发展迅速。太阳能电池是一种吸收光能产生电能的半导体光电二极管&#xff0c;硅基电池作为第一代太…

beego API 自动化文档

API 全局设置 必须设置在 routers/router.go 中&#xff0c;文件的注释&#xff0c;最顶部&#xff1a; // APIVersion 1.0.0 // Title mobile API // Description mobile has every tool to get any job done, so codename for the new mobile APIs. // Contact astaxiegmai…

解决Windows下VSCode控制台乱码问题

我们在Windows使用VSCode编写C/C程序时&#xff0c;如果代码中的中文字符串使用的是UTF8编码&#xff0c;且代码内没有设置控制台的输出编码&#xff0c;或者编译时没有指定运行时编码&#xff08;GCC可以在编译时使用-fexec-charsetGBK来指定运行时的字符串编码&#xff1b;cl…

本地读取Excel文件并进行数据压缩传递到服务器

在项目开发过程中&#xff0c;读取excel文件&#xff0c;可能存在几百或几百万条数据内容&#xff0c;那么对于大型文件来说&#xff0c;我们应该如何思考对于大型文件的读取操作以及性能的注意事项。 类库&#xff1a;Papa Parse - Powerful CSV Parser for JavaScript 第一步…

计算机网络学习first day

In the first day.  首先&#xff0c;我们要先有清晰地学习思路&#xff0c;然后介绍计算机网络的发展及在信息时代的各类应用及带来的一些负面问题。然后是对因特网进行概述&#xff0c;包括网络&#xff0c;互联网和因特网的相关概念&#xff0c;因特网发展的三个历史阶段&a…

16位单片机单片机S1C17153

16位单片机单片机 .16KB ROM / 2KB内存 * S1C17653对于程序开发很有用。 .产生具有内置振荡器的操作时钟。 - OSC3B振荡器电路&#xff1a;2MHz/1MHz/500kHz&#xff08;类型&#xff09;内部振荡器电路 -OSC1无振荡器电路&#xff1a;32.768 kHz&#xff08;类型&#xf…

对MODNet 主干网络 MobileNetV2的剪枝探索

目录 1 引言 1.1 MODNet 原理 1.2 MODNet 模型分析 2 MobileNetV2 剪枝 2.1 剪枝过程 2.2 剪枝结果 2.2.1 网络结构 2.2.2 推理时延 2.3 实验结论 3 模型嵌入 3.1 模型保存与加载 法一&#xff1a;保存整个模型 法二&#xff1a;仅保存模型的参数 小试牛刀 小结…

Unity工程没有创建.sln文件,导致打开C#文件无法打开解决方案

最近又开始折腾些Unity的小项目&#xff0c;重新遇到一些常见的小问题 点击报错文件 却没有打开文件 于是查看了下打开Window->Package Manager 选择Unity Registry 搜索Visual Studio Editor&#xff0c;发现并没有安装 同理&#xff0c;也可以安装VSCode的插件 问题解决了…

R语言rvest爬虫如何设置ip代理?

前言 在R语言中使用rvest进行网络爬虫时&#xff0c;可以使用代理服务器来隐藏真实IP地址。有一些R包可以帮助爬虫中设置代理&#xff0c;其中一个常用的包是httr。以下是一个简单的例子&#xff0c;演示如何在rvest中设置IP代理 教程 一、获取代理IP并提取 二、详情设置 l…

开发实践8_REST

一、Django REST Framework, Django View & APIView MTV模式实现前后端分离。Representational State Transfer 表现层状态转化。Representation 资源&#xff08;Resource a specific info. on net.&#xff09;具体呈现形式。ST 修改服务端的数据。修改数据 POST请求。…

C#,入门教程(07)——软件项目的源文件与目录结构

上一篇&#xff1a; C#&#xff0c;入门教程(06)——解决方案资源管理器&#xff0c;代码文件与文件夹的管理工具https://blog.csdn.net/beijinghorn/article/details/124895033 创建新的 C# 项目后&#xff0c; Visual Studio 会自动创建一系列的目录与文件。 程序员后面的工…

SERVLET API

SERVLET API Servlet API是用于创建servlet的java类和接口的集合。这些类和接口存放在javax.servlet和javax.servlet.http包中。 javax.servlet包 javax.servlet包的类和接口用于servlet和客户机之间的通信。创建servlet时,需要直接或通过扩展实现Servlet接口的类来实现Serv…

从传统管理到数字化转型——易点易动固定资产管理系统的应用

在数字化时代&#xff0c;企业管理正迎来一场革命性的转变。固定资产管理作为企业管理的重要组成部分&#xff0c;也需要适应数字化转型的潮流。易点易动固定资产管理系统作为一项先进的数字化工具&#xff0c;为企业提供了高效、便捷的资产管理解决方案。本文将介绍易点易动固…

VMware workstation平台下配置Fedora-Server-39-1.5虚拟机网络

VMware workstation平台下配置Fedora-Server-39-1.5虚拟机网络 Fedora包含的软件以自由及开放源码许可来发布&#xff0c;并旨在成为该技术领域的领先者。Fedora在专注创新、抢先集成新技术、与上游Linux社区紧密工作方面拥有良好名声。该文档适用于在VMware workstation平台下…

【爬虫、数据可视化实战】以“人口”话题为例爬取实时微博数据并进行舆情分析

前言&#xff1a; 近期在weibo上讨论的比较热的话题无非就是“人口”了。TaoTao也看了一些大家发的内容。但是感觉单纯的看文字内容不能很直观的反应出来大家的关切。索性就使用爬虫对数据进行爬取&#xff0c;同时结合着数据可视化的方式让数据自己开口说话。那么接下来就让我…

单片机中MCU跑RTOS相比裸机的优势

经常有读者问关于RTOS的问题&#xff0c;比如&#xff1a;我现在要不要学习RTOS&#xff1f; 学习RTOS有什么好处&#xff1f; 我的项目要不要跑RTOS&#xff1f; 问这些问题&#xff0c;其实归根结底还是对RTOS理解的不够&#xff0c;项目开发的经验还不足等。针对这部分朋友…

鸿蒙自定义刷新组件使用

前言 DevEco Studio版本&#xff1a;4.0.0.600 1、RefreshLibrary_HarmonyOS.har&#xff0c;用于HarmonyOS "minAPIVersion": 9, "targetAPIVersion": 9, "apiReleaseType": "Release", "compileSdkVersion": "3.…

OpenHarmonyOS-gn与Ninja

GN语法及在鸿蒙的使用 [gnninja学习 0x01]gn和ninja是什么 ohos_sdk/doc/subsys-build-gn-coding-style-and-best-practice.md GN 语言与操作 一、gn简介 gn是generate ninja的缩写&#xff0c;它是一个元编译系统&#xff08;meta-build system&#xff09;,是ninja的前端&am…