数据结构课程设计：基于有序表的仓库管理系统

最新推荐文章于 2024-04-26 19:42:01 发布
最新推荐文章于 2024-04-26 19:42:01 发布
阅读量3.2k 收藏 80
点赞数 8
分类专栏： 课程设计 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HsingYang/article/details/111966060
版权

文章首发网址：星星点灯的技术栈（https://www.xxdiandeng.cn），欢迎关注点灯君的原创博客网站

《数据结构》课程设计报告

课程设计选题：仓库管理系统

题目与要求

问题描述

某电子公司仓库中有若干批次的同一种电脑，按价格、数量来存储。
要求实现功能:

  1. 初始化 n 批不同价格电脑入库；
  2. 出库：销售m台价格为p的电脑；
  3. 入库：新到m台价格为p的电脑；
  4. 盘点：电脑的总台数，总金额，最高价，最低价，平均价格。

注：每个数据元素含有价格与数量；同一价格的电脑存储为一个数据元素。

系统涉及知识点

仓库管理系统可以使用顺序表、有序表、单链表、有序循环链表等实现，本设计采用有序表实现。
所谓有序表，是指这样的线性表，其中所有的元素以递增或递减方式有序排列。
首先要指出的是，有序表是基于顺序表而延伸出来的一种数据结构，其共同点是用一组地址连续的存储单元依次存储线性表的数据元素。
其次，是有序表的独特之处，它其中的数据元素按照一定的顺序有序排列。
仓库管理系统适合采用有序表，原因是可以按照商品的价格或数量进行有序排列，方便用户比对价格、数量。

功能要求

  1. 初始化仓库：初始化n批不同型号的电脑入库；

  2. 入库：新到m台价格为p的电脑；

  3. 出库：销售m台价格为p的电脑；

  4. 盘点仓库：列出仓库的关键数据：电脑的总台数、总金额、最高价、平均价格等；

    按照有序表的特点以及所使用的编程语言（C++）的特性，本程序还提供了以下功能：

  5. 查询某一型号的电脑的价格、数量；

  6. 重新对仓库数据按照一定规则排序；

  7. 导出仓库数据到外部文件；

  8. 从外部文件导入数据，以初始化仓库。

功能设计

数据结构定义

一、基本数据元素：电脑

typedef struct computer {
    char type[50];  // 型号
    double price;   // 价格
    int number;     // 数量
} Computer, ElemType;

基本数据元素电脑（Computer/ElemType）采用结构体表示，用于存储某一类电脑的信息：型号（type[50]）、价格（price）、库存数量（number）。
二、数据结构：有序表

typedef struct {
    ElemType *elem;     // 基地址
    int length;         // 当前有效数据的个数
    int listsize;       // 当前存储容量(单位是sizeof(ElemType))
    bool isInit{false}; // 顺序表是否已经初始化
    int sortWay{1};     // 顺序表的排序方式
} SqList;

数据结构有序表（SqList）由以下几个部分组成：

  1. 数组指针elem指示有序表的基地址；
  2. length指示有序表的当前有效数据个数（长度）；
  3. listsize指示有序表当前分配的存储空间大小，一旦因插入数据元素（Computer）而空间不足时，可进行再分配；
  4. isInit指示有序表是否已经初始化（即是否有一个确定的基地址）；
  5. sortWay指示有序表的排序方式，按照值的不同，对应的有序表排序方式也不同。本程序具体设计了以下四种排序方式：1-按照价格升序、2-按照价格降序、3-按照数量升序、4-按照数量降序。

整体的数据结构如下图所示：

模块图

入库

入库有两种方式，一是在仓库中已有和待入库电脑型号相同的数据，此时，检查给出的价格是否与仓库中一致，若一致，同意用户的入库操作。然后只需更改仓库中此种电脑型号的数量。
示意图如下：

第二种方式，入库一种新型号的电脑，则应该按照有序表的排序方式（sortWay）在正确位置插入元素。
示意图如下：

出库

可以出库的前提是，在仓库中有待出库型号的电脑且仓库中的库存数量大于等于待出库数量。
第一类情况，待出库电脑的数量在库存中充足（即库存数量大于待出库数量），此时只需更改相应的数据元素。
示意图如下：

第二类情况，此种型号的电脑恰好全部出库完，则需要删除相应的数据元素。
示意图如下：

功能代码

初始化动态顺序表

有序表的数据结构是基于顺序表实现的，所以在进行一切操作前，应当初始化一个空的动态顺序表。
代码如下：

Status InitSqList(SqList &L, int n) {
    auto listsize{((n / 10) + 1) * 10}; // 确定顺序表初始内存占用空间
    L.elem = new ElemType[listsize];    // 分配基地址、顺序表内存
    if (!L.elem)    // 内存不足
        return OVERFLOW;
    L.length = 0;   // 此时顺序表还没有元素，L.length为0
    L.listsize = listsize;
    return OK;
}

有序表初始分配的内存空间（listsize）并没有简单采用一个常数大小（如10个ElemType字节），这样不用限制用户输入的电脑类型最大个数，对用户友好。具体是通过给定的n，计算表达式((n/10)+1)*10，使得初始分配的内存为10的整数倍大小的ElemType字节，比如n为12，表达式((n/10)+1)*10则为20。
需要注意的是，初始化动态顺序表时，还暂无数据元素，L.length应为0。

创建（初始化）仓库

创建仓库的前提是，已经初始化过一个空的动态顺序表，这个检测可以在主函数中完成。
创建有序表式的仓库步骤：

  1. 输入n个数据元素，存储到顺序表中；
  2. 对已创建的顺序表按照有序表的排序方式（L.sortWay）进行快速排序。
  3. 更新有序表的相应参数（length、isInit、sortWay）
    代码如下：
void CreateWarehouse(SqList &L, int n, int sort_way) {
    cout << "请输入这" << n << "种电脑各自的型号、单价、总数:(以空格分隔)" << endl;
    // 输入n个数据元素
    for (int i = 0; i < n; i++)
        cin >> L.elem[i].type >> L.elem[i].price >> L.elem[i].number;
    // 按照sort_way对刚创建的顺序表排序
    switch (sort_way) {
        case 1:
            // 按价格升序
            sort(L.elem, L.elem + n, cmp1);
            break;
        case 2:
            // 按价格降序
            sort(L.elem, L.elem + n, cmp2);
            break;
        case 3:
            // 按数量升序
            sort(L.elem, L.elem + n, cmp3);
            break;
        case 4:
            // 按数量降序
            sort(L.elem, L.elem + n, cmp4);
            break;
        default:
            break;
    }
    // 更新L的参数
    L.sortWay = sort_way;
    L.length = n;
    L.isInit = true;
}

如果使用文件流创建仓库，那么代码略有不同，这部分属于C++的知识。
不同代码（输入n数据元素）如下：

string s;
// 从文件流输入n个数据元素
for (int i = 0; i < n; i++) {
    ImportFile >> L.elem[i].type >> L.elem[i].price >> L.elem[i].number;
    getline(ImportFile, s);
}

显示仓库

顾名思义，就是将仓库的数据打印出来。
代码如下：

// 显示仓库
void PrintWarehouse(SqList L) {
    if (!L.length)
        cout << "当前仓库没有数据!" << endl;
    else {
        cout << "当前仓库数据如下:" << endl;
        string sort_way;
        switch (L.sortWay) {
            case 1:
                sort_way = "(按照价格升序)";
                break;
            case 2:
                sort_way = "(按照价格降序)";
                break;
            case 3:
                sort_way = "(按照数量升序)";
                break;
            case 4:
                sort_way = "(按照数量降序)";
                break;
            default:
                break;
        }
        cout << sort_way << endl;
        cout << "-------------------------------------------------------" << endl;
        cout << setLeft
             << setw(5) << "序号"
             << setw(20) << "型号"
             << setw(15) << "单价"
             << setw(15) << "数量"
             << endl;
        cout << "-------------------------------------------------------" << endl;
        for (int i = 0; i < L.length; i++)
            cout << setLeft
                 << setw(5) << i + 1
                 << setw(20) << L.elem[i].type
                 << setw(15) << L.elem[i].price
                 << setw(15) << L.elem[i].number
                 << endl;
        cout << "-------------------------------------------------------" << endl;
    }
}

入库

入库要考虑两种情况，第一种情况，仓库中已经有和待入库电脑相同型号的数据元素，那么需要先比较价格是否一致（不一致拒绝用户的入库操作），然后更改仓库中此种电脑数据元素的数量值。
第二种情况入库一种新型号的电脑，那么则要插入一个新的数据元素（Computer）到仓库中，并且在插入之前还要检查有序表的内存空间（listsize）是否充足，如果不足，则需要再分配有序表的内存大小，即为顺序表增加一个大小为存储LISTINCREMENT个数据元素的空间。然后，根据有序表的排序方式（L.sortWay），找到可以插入元素的地址。插入时，先将该地址及以后的地址全部后移一位，接着将当前地址写入要入库的数据元素。
代码如下：

Status Enter(SqList &L, const Computer &c) {
    // 寻找仓库中是否已经有和c.type同类型的电脑
    for (int i = 0; i < L.length; i++) {
        if (strcmp(c.type, L.elem[i].type) == 0) {
            if (c.price == L.elem[i].price) {   // 检查价格价格是否与c.price相等
                L.elem[i].number += c.number;
                return OK;
            } else {
                cout << "提示:" << endl;
                showInfo(L.elem[i]);
                return ERROR;
            }

        }
    }

    // 入库一个新类型的电脑
    if (L.length >= L.listsize) {   // 顺序表占用空间不足
        // 申请新的基地址、内存空间
        auto *newbase = (ElemType *) realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)
            return OVERFLOW;
        L.elem = newbase;   // L的基地址更改为newbase
        L.listsize += LISTINCREMENT;
    }
    // 按照L.sort_way对插入到顺序表中
    int item{L.length}; // 确定要插入的位序
    for (int i = 0; i < L.length; i++) {
        switch (L.sortWay) {
            case 1: {
                if (c.price < L.elem[i].price) {
                    item = i;
                    goto change_sq;
                }
            }
                break;
            case 2: {
                if (c.price > L.elem[i].price) {
                    item = i;
                    goto change_sq;
                }
            }
                break;
            case 3: {
                if (c.number < L.elem[i].number) {
                    item = i;
                    goto change_sq;
                }
            }
                break;
            case 4: {
                if (c.number > L.elem[i].number) {
                    item = i;
                    goto change_sq;
                }
            }
                break;
        }
    }
    change_sq:
    ElemType *q = &L.elem[item];
    // 将q及q以后的元素全部后移一位
    for (ElemType *p = L.elem + L.length - 1; p >= q; p--)
        *(p + 1) = *p;
    // 将新元素赋给q
    *q = c;
    L.length++;
    return OK;
}

要注意的是如果是入库一种新型号的电脑，完成操作后，应当将有序表的长度加1（L.length++）。

出库

出库要考虑以下几种情况：

  1. 仓库中是否有待出库电脑的型号的相应数据元素，如果没有找到相应的电脑型号，则应当拒绝用户的出库操作；
  2. 仓库中现有库存数量是否充足，满足出库要求，如果库存数量小于待出库数量，则应当拒绝用户的出库操作；
  3. 如果库存数量大于待出库数量，那么只需更改相应数据元素的数量值；
  4. 如果库存数量恰好等于待出库数量，那么此时这种型号的电脑应从仓库中“剔除”。具体操作是，找到该数据元素的地址，将该地址及以后的地址全部前移一位。最后，更新L.length参数。

代码如下：

Status Out(SqList &L, const char *type, int num) {
    // 确定要出库元素的位序
    int item{L.length + 1};
    for (int i = 0; i < L.length; i++) {
        if (strcmp(type, L.elem[i].type) == 0) {
            item = i;
            break;
        }
    }
    // 没有找到要出库元素的位序，说明在仓库中没有元素，返回错误
    if (item > L.length)
        return -1;

    // 确定要出库元素现有库存的数量是否可以出库
    if (num < L.elem[item].number) {
        // 正常出库
        L.elem[item].number -= num;
        return OK;
    } else if (num == L.elem[item].number) {
        // 全部出库
        cout << "提示:" << endl
             << L.elem[item].type << "型号的电脑已全部出库!" << endl;

        // 将p及p以后的元素全部后移一位
        for (ElemType *p = &L.elem[item + 1]; p <= &L.elem[L.length - 1]; p++) {
            *(p - 1) = *p;
        }
        L.length--;
        return OK;
    } else {
        // 库存不足
        cout << "提示:" << endl;
        showInfo(L.elem[item]);
        return ERROR;
    }
}

查询电脑数据

查询电脑数据，只需从基地址开始遍历，直到找到数据元素的型号和待查询的型号相同，那么返回电脑信息。
可以定义一个item参数，初始值为L.length + 1，如果找到数据元素，则将其更新为数据元素的逻辑位序。如果遍历结束，item都未更新，说明未找到。因为数据元素的最大逻辑位序是有序表的表长（L.length），所以判断是否找到数据元素的条件是：item > L.length。
代码如下：

void getInfo(SqList L, const char *type) {
    // 确定要查找的电脑的元素位序
    int item{L.length + 1};
    for (int i = 0; i < L.length; i++) {
        if (strcmp(type, L.elem[i].type) == 0) {
            item = i;
            break;
        }
    }
    if (item > L.length)
        cout << "没有找到" << type << "型号的电脑" << endl;
    else {
        cout << "信息如下:" << endl;
        showInfo(L.elem[item]);
    }
}

盘点仓库

从基地址开始遍历，求得关键数据：总台数（numSum）、总金额（priceSum）、最高价（priceMax）、最低价（priceMin）、平均价（priceAverage）。
代码如下：

void Check(SqList L) {
    int numSum{0};
    double priceSum{0.0}, priceMax{L.elem[0].price}, priceMin{L.elem[0].price}, priceAverage{0.0};
    vector<char *> priceMaxComputer;    // 存储价格最高的电脑的类型名
    vector<char *> priceMinComputer;    // 存储价格最低的电脑的类型名

    if (!L.length) {
        cout << "当前仓库没有数据!" << endl;
    } else {
        // 求总数、总金额、最高价、最低价
        for (int i = 0; i < L.length; i++) {
            numSum += L.elem[i].number;
            priceSum += L.elem[i].price * L.elem[i].number;
            priceMax = max(priceMax, L.elem[i].price);
            priceMin = min(priceMin, L.elem[i].price);
        }
        // 记录价格最高、最低的电脑类型名
        for (int i = 0; i < L.length; i++) {
            if (L.elem[i].price == priceMax)
                priceMaxComputer.push_back(L.elem[i].type);
            if (L.elem[i].price == priceMin)
                priceMinComputer.push_back(L.elem[i].type);
        }
        // 求平均价
        priceAverage = priceSum / numSum;
        // 输出信息
        cout << "盘点数据如下" << endl
             << "电脑的总台数: " << numSum << endl
             << "电脑的总金额: " << priceSum << endl
             << "电脑的最高价: " << priceMax << endl
             << "           + 对应的型号是: ";
        for (const auto &c:priceMaxComputer)
            cout << c << "\t";
        cout << endl;
        cout << "电脑的最低价: " << priceMin << endl
             << "           + 对应的型号是: ";
        for (const auto &c:priceMinComputer)
            cout << c << "\t";
        cout << endl;
        cout << "电脑的平均价格: " << priceAverage << endl;
    }
}

这里定义了两个char*向量（priceMaxComputer、priceMinComputer），用以存储价格最高的电脑的类型名、最低的电脑的类型名，因为可能若干种型号的电脑都是最高价或最低价，所以使用C++的向量数据结构比较合适。这样，可以显示出最高价、最低价相应的电脑类型名，对用户友好。

重新对仓库排序

只需按照给定的排序方式，对仓库进行快速排序，然后更改L.sortWay参数为相应值。
代码如下：

cout << "请输入要重新对仓库排序的主要方式" << endl
     << "1. 按价格升序 2. 按价格降序" << endl
     << "3. 按数量升序 4. 按数量降序" << endl
     << "选择1-4:";
auto select = input_number(1, 4);
switch (select) {
    case 1:
        sort(L.elem, L.elem + L.length, cmp1);
        break;
    case 2:
        sort(L.elem, L.elem + L.length, cmp2);
        break;
    case 3:
        sort(L.elem, L.elem + L.length, cmp3);
        break;
    case 4:
        sort(L.elem, L.elem + L.length, cmp4);
        break;
    default:
        break;
}
L.sortWay = select;
cout << "重新排序成功!" << endl;

其中，4种排序方式的代码如下：

// computer排序方式：按价格升序
bool cmp1(const Computer &a, const Computer &b) {
    return a.price < b.price;
}

// computer排序方式：按价格降序
bool cmp2(const Computer &a, const Computer &b) {
    return a.price > b.price;
}

// computer排序方式：按数量升序
bool cmp3(const Computer &a, const Computer &b) {
    return a.number < b.number;
}

// computer排序方式：按数量降序
bool cmp4(const Computer &a, const Computer &b) {
    return a.number > b.number;
}

导出仓库数据到文件

原理和显示仓库大同小异，只是多了文件流的操作。
代码如下：

void output(SqList L, const string &filename) {
    // 定义输出文件流filename.txt
    ofstream OutFile(filename + ".txt");
    // 输出文件头，用于下次输入时识别文件
    OutFile << "Computer Warehouse Data" << endl;
    if (!L.length)
        OutFile << "no data" << endl;
    else {
        OutFile << "The information is as follows:" << endl;
        switch (L.sortWay) {
            case 1:
                OutFile << "Sort Way: 1 (Ascending by price)" << endl;
                break;
            case 2:
                OutFile << "Sort Way: 2 (Descending by price)" << endl;
                break;
            case 3:
                OutFile << "Sort Way: 3 (Ascending by number)" << endl;
                break;
            case 4:
                OutFile << "Sort Way: 4 (Descending by number)" << endl;
                break;
            default:
                break;
        }
        OutFile << "Total Type: " << L.length << endl;

        // 输出数据信息
        for (int i = 0; i < L.length; i++)
            OutFile << L.elem[i].type << " "
                    << L.elem[i].price << " "
                    << L.elem[i].number
                    << endl;
        // 关闭文件
        OutFile.close();
    }
}

调试与测试

注意：本设计使用的编译器是G++ 8.1.0，在Windows平台上编译、运行成功。
编译命令为：“g++ main.cpp sqlist.cpp -o main”（不含引号）。

调试分析

一、创建仓库
为方便用户操作，本程序可以导出仓库数据到文件，然后在下次操作时，可以用此文件做仓库的初始化。这是在考虑到程序的友好性后增加的功能。
无论是手动创建还是从文件导入，方法是大同小异的。
本模块时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)（快速排序 O ( n l o g n ) O(nlogn) O(nlogn)）
二、入库、出库、查询、盘点仓库
时间复杂度均为： O ( n ) O(n) O(n)
考虑到程序的友好性，对入库、出库、查询的拒绝操作均给出具体信息。比如，在出库时如果库存数量小于待出库数量，则先显示当前库存，然后提示库存数量不足。
三、其他
菜单和主函数设计中，由于经常需要检测输入数字是否在某一范围内，使得生成大量重复代码。于是，将这些代码设计成函数，增加了代码的可读性。并且考虑到，用户的误输入（非数字）会导致程序崩溃，设计了正则表达式匹配，检测用户输入。
函数代码如下：

// 输入from至end范围内的数字
int input_number(int from, int end) {
    auto select{0};
    string input;
    regex r("[0-9]*");  // 正则表达式:数字0-9，可以出现多次
    while (true) {
        cin >> input;
        bool isNumber = regex_match(input,r);
        if (!isNumber)  // 如果input和正则表达式匹配
            cout << "输入错误，请输入数字" << from << "-" << end << ":";
        else {
            select = atoi(input.c_str());
            if (select < from || select > end)
                cout << "输入错误，重新输入" << from << "-" << end << ":";
            else
                break;
        }
    }
    return select;
}

另外一个是，如果用户在初始化仓库的情况下，进行入库、出库等操作，亦会导致程序崩溃。所以，后来在有序表中增加了一个参数isInit，用于指示当前有序表是否已经初始化。在每次操作之前，检测是否已经初始化，这样避免了这一类型的崩溃。

用户手册

启动本程序后，按照菜单的提示进行操作即可。
注意：

  1. 第一步必须先初始化仓库，否则，您无法进行其他的操作，将返回“仓库还未初始化!”。
  2. 初始化仓库时，可以选择“2.从外部文件导入”，但前提是，该外部文件要存在，且是以前程序生成的导出合法文件。否则，不存在的文件将提示“没有文件/文件无法打开”，不是合法文件将提示“文件内容不符合要求”，这会导致初始化仓库失败。所以，请检查您输入的文件名和文件内容！
  3. 建议在入库操作之前先显示仓库，确保增加仓库中某一电脑型号的数量时，输入的价格和仓库中一致；
  4. 建议在出库操作之前先显示仓库，确保仓库中有您想要出库的电脑型号，以及其数量充足；
  5. 您可以选择菜单项“7.重新对仓库排序”，按照您喜爱的方式对仓库排序，本程序提供了四种主要排序方式：1-按照价格升序、2-按照价格降序、3-按照数量升序、4-按照数量降序
  6. 建议每次结束程序前，导出仓库数据到文件，这样可以保存仓库数据，方便下次操作。

测试过程

本设计给出了一个输入文件info.txt
内容如下：

Computer Warehouse Data
The information is as follows:
Sort Way: 1 (Ascending by price)
Total Type: 12
RedmiBook-14 3299 30
Dell-G5 5699 14
Surface-Pro-7 5788 20
Lenovo-Air14 5999 17
Lenovo-R7000 6057 12
Lenovo-Yoga14 6299 8
Lenovo-Pro14 6299 10
MiBook-Pro-15.6 6999 13
Dell-G3 6999 15
Dell-XPS13 8888 5
MacBook-Pro-13 9199 5
MacBook-Pro-16 17399 3

下面是各种操作的输出结果（截图）：
1、菜单显示

2、初始化仓库

3、显示仓库

4、入库
入库Dell-G5 5699 2：

入库后显示仓库：

入库Huawei-MateBook-X 8999 2：

入库后显示仓库：

5、出库
出库Huawei-MateBook-X 2:

出库后显示仓库：

6、查询
查询Lenovo-Pro14

7、盘点仓库

8、重新对仓库排序
按数量升序对仓库排序：

显示重新排序后的仓库：

总结

通过本次课程设计，在数据结构课程中所学到的顺序表基础上，实现了有序表，并通过基本数据元素（Computer）和数据结构（SqList）的设计，实现了简易的仓库管理系统。
在本次课程设计中，也学习到很多的C++的知识，如STL中数据结构与算法的应用（vector、sort）、文件流（fstream）。
通过设计输入输出文件的功能，解决了以往繁琐的数据输入步骤。同时，也增加了程序的友好性。
通过输入检测、正则表达式匹配，解决了非法输入导致程序崩溃的问题。
但限于编程能力，本程序仍存在某些问题，如初始化时，没有对输入相同型号的数据做处理，这是程序的改进方向。

参考文献

严蔚敏，吴伟民.数据结构（C语言版）[M]. 北京：清华大学出版社，1997.

严薇敏，吴卫民.数据结构题集（C 语言版）[M].北京：清华大学出版社，1997.

[美]Y.Danie Liang. C++程序设计.[M].北京：机械工业出版社，2015.

Michael Wong，IBM XL编译器中国开发团队.深入理解C++11：C++11新特性解析与应用.[M].北京：机械工业出版社，2013.

附录

源代码见Github仓库

爱编程的小芯
关注
专栏目录
算法与数据结构课程设计-家电商场仓库管理.doc
05-26
**《算法与数据结构课程设计—家电商场仓库管理》**是一个典型的基于数据结构和算法的应用项目，旨在通过解决实际问题来加深对数据结构的理解和应用能力。该项目的目标是开发一个能够高效管理家电商场仓库中各种商品...
数据结构课设：仓库管理系统（C++）
m0_51409962的博客
05-06 5173
文章目录前言一、仓库要求是什么？二、具体实现1.结点设计2.进货操作3.退货操作4.存文件5.读文件6.根据售价排序(冒泡)7.查找（关键值）总结 前言 因为我的课设（最短路径）完成的比较早，于是我又做了仓库管理系统的设计。 整体代码功能比较简单，可以给小伙伴们提供一些参考。 一、仓库要求是什么？ 用链表实现进货，退货，排序（根据售价），关键值（名称）搜索，显示所有货物，商品数量不足时提醒补货，读取仓库文件，保存仓库文件，选择不同的仓库。 二、具体实现 1.结点设计 代码如下： struct Node
C语言数据结构课程设计--仓库管理系统
aijiayi00的博客
02-06 4625
这里time.h头文件来获取货物入库时间。 直接上代码，当然头文件的规划不是很好。可以自己再改改. 因为这里使用的是栈，对于栈的排序算法我并没有写好。 我这里采取的是将栈中数据存入文件中，再放入结构体数组中。再进行排序。 这里只使用了一点sqlite3数据库。比较混的。可以就当略过。 bbbb.h： #ifndef bbbb_c #define bbbb_c #include<stdio.h> #include<time.h> #include<stdl
数据结构课程设计 仓储管理系统
shaozheng0503的博客
01-22 1463
仓储管理系统
数据库开发综合案例——仓库管理系统设计
热门推荐
weixin_51970555的博客
09-29 1万+
数据库表设计-核心表创建 数据库整体设计 头歌实验代码 数据库表设计-项目职员表 头歌实验代码 数据库表设计-关联表 头歌实验代码
django+MySQL 超市仓库管理系统计算机毕业设计源码96723
weixin_bysjlw985的博客
07-13 447
MySQL是一个关系型数据库管理系统，它的范围包括了膝上型计算机、台式机、超市服务器。20世纪，最初的MySQL是由Sybase专门为UNIX系统开发的，后来微软将它移植到了WindowsNT系统上。从1994年开始，微软发布独立于Sybase开发的MySQL版本，而Sybase在20世纪90年代后期，就已经停止使用MySQL这个名称。 MySQL提供MySQL多个拷贝之间以及其他数据库系统的复制服务。其中的分析服务是属于系统的一个完整部分，包括了：联机分析处理（OLAP）和数据挖掘工具。MySQL提供了一
资料总结分享：数据库篇：设计步骤
最新发布
weixin_69558614的博客
04-26 2886
数据库试运行合格后,数据库开发工作基本完成,即可投入正式运行了。但由于应用环境不断变化,数据库运行过程中物理存储也不断变化,对数据库设计进行评价、调整与修改等维护工作是一个长期的任务。在数据库运行阶段,对数据库经常性的维护工作主要是由数据库管理员 DBA 完成的。数据库的维护工作包括4个方面。
计算机毕业设计-基于Java+SSM架构的企业仓储管理系统项目开发实战(附论文+源码)
2301_76953549的博客
03-30 844
本选题则旨在通过标签分类管理等方式，实现管理员；个人中心、公告信息管理、员工管理、供应商管理、商品分类管理、供应商货物管理、货物采购管理、商品信息管理、商品入库管理、商品出库管理、在线沟通管理、货物盘点管理，供应商；个人中心、供应商货物管理、货物采购管理、在线沟通管理，员工；个人中心、公告信息管理、供应商管理、供应商货物管理、货物采购管理、商品信息管理、商品入库管理、商品出库管理、在线沟通管理，等信息管理功能，从而达到对企业仓储管理系统信息的高效管理。
课程设计 物资管理系统
01-11
物资管理系统是基于ASP.NET技术与SQLServer数据库设计的一款应用于企业管理日常物资进出、存储和查询的软件系统。此类系统对于企业资源规划（ERP）至关重要，它能够提高库存管理效率，减少物资浪费，确保物资流动的...
Oracle仓库标准管理系统专业课程设计方案报告数据库部分含Oracle代码.pdf
07-05
- 这些设计和对象的创建共同构成了仓库管理系统的数据库核心，通过Oracle数据库引擎执行，确保系统的高效稳定运行。 综上所述，Oracle仓库标准管理系统结合了数据库理论和实践，运用Oracle数据库的强大功能，实现...
数据结构课程设计报告-仓库管理系统
03-12
本系统有对库存货品信息的输入、插入、删除、查找等功能，并能将建立和更新的库存信息保存于文件供输出或打印。对于查找、删除等功能要求能按货品名、货品号分别进行。每个货品的相关信息包括：货品号、货品名、货品库存量、进货日期、货品生产厂家及供应商等。
c语言版数据结构仓库管理系统课程设计
07-17
学生课程设计
仓库管理系统 程序 数据结构（C语言） 课程设计
04-06
仓库管理系统 程序 数据结构（C语言） 课程设计
数据结构报告设计仓库管理系统
12-28
数据结构仓库管理系统，里面都代码，有文字解说等等，自我感觉不错，拿出来分享了
_Hadoop+JavaWeb大数据分析可视化系统.pdf
08-22
4. **Hive**：Hive是一个基于Hadoop的数据仓库工具，可以将结构化数据文件映射为一张数据库表，并提供SQL-like接口进行查询。它简化了对大数据的分析工作，将SQL查询转换为MapReduce任务执行，适合处理非实时的批量...
CourseScheduleManagementSystem:课程计划管理系统
05-19
【课程计划管理系统】是一个专为教育机构或学校设计的应用程序，旨在高效地管理和安排课程。系统的核心目标是优化教育资源分配，确保课程的有序进行，并方便师生进行课程查询、选课等操作。它通常包含了诸如学生信息...
php+mysql仓储管理系统 的设计与实现（附源码 论文 配置 讲解）
shenchengyv的博客
10-27 1642
虽然近年来我们信息化进程逐年加快，但仍然有一大批企事业单位在利用传统手段进行信息管理工作，ERP系统应用率不足，信息化程度普遍不高，因此，结合快递物流的行为习惯与实际情况，特决定开发一个仓储管理系统，将通过计算机和互联网，把仓储的相关信息以网络技术的形式整合在一起，通过利用丰富的网络资源，做到科学化、信息化、规范化的对企业信息过行相应管理，解决原手段的地域性空间性的相应限制，提高企业的管理水平。超级管理员登陆后，主要功能模块包括员工管理，仓库管理，盘点库存，业务量分折，个人资料，系统管理。
仓库管理系统设计
qq_61141142的博客
11-05 803
随着全球信息科技的飞速发展，当今社会已经进入了信息化的社会，企业信息管理的重要性也越来越突出。仓储管理是商业企业经营管理中的重要环节，也是一个企业能否取得效益的关键。仓储管理决策的正确与否直接影响到生产企业的效益问题，如果能够及时掌握销售和库存情况，合理配置企业资源，加快资金周转，减少企业商品在仓库中的积压时间，加快物质的流通频率，那么企业就能取得最佳的效益。然而，在传统的仓储管理中，企业领导者往往由于收集不到底层的数据而不能进行科学决策，最终导致企业资源的浪费，造成企业的运营成本居高不下。
数据结构课程设计——产品销售管理系统（源代码是完全免费的）
qq_17131933的博客
02-13 1698
产品销售管理系统含有用户的登录、注册账号程序、管理人员的登录、注册账号、查看产品、修改产品信息等管理程序；它的大致结构如下：该系统通过输出程序、购买程序、来实现商店销售信息管理程序的显示商品信息功能、购买等功能，通过使用两个不同的输出函数，使得不同的身份，所看的商品信息而不同。（避免用户每次都要注册账号的事情发生）（以该程序的第一界面的选项进行演示）本程序用来查看用户登录的账号是否正确，对新用户的账号注册，并对账号信息进行写入文档等相关的处理，使用流程图显示相关功能。该应用的整体是通过链表进行实现的。
数据结构课程设计：求解有序链表交集
这篇文档是关于数据结构课程设计的一个项目，目标是实现两个有序链表的交集运算。项目作者是张喆，来自同济大学软件学院的软件工程专业，由指导教师张颖指导。这个设计旨在解决在大量数据下求集合交集的复杂性和错误...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值