精华内容
下载资源
问答
  • 商品货架管理

    2021-05-17 17:29:21
    4.商品货架管理 需求分析: 商品货架可以看为栈,在每次上货时,需翻转货架,使新商品在栈的底部,实现进货,出售商品,展示货架上商品的操作 概要设计: 抽象数据结构: ADT{ InitStack(SqStack& S) //...

    4.商品货架管理

    1. 需求分析:
      商品货架可以看为栈,在每次上货时,需翻转货架,使新商品在栈的底部,实现进货,出售商品,展示货架上商品的操作
    2. 概要设计:
    • 抽象数据结构:

    ADT{

    InitStack(SqStack& S) //初始化栈S
    Push(SqStack& S, ElemType e) //入栈
    Pop(SqStack& S, ElemType& e) //出栈
    Purchase_Product_noEmpty //货架不为空时进货
    Purchase_Product_Empty //货架为空时进货
    Sell_Product(SqStack& S, int num)//出售商品
    void Inquire_Number(SqStack S)//展示货架当前商品
    }

    • 程序用到的函数及层次关系:

    main{

      1. Purchase_Product_Empty() {
        Push()
        }
      2. Purchase_Product_noEmpty() {
        • InitStack()
        • Pop()
        • Push()
          }
    • Sell_Product(){
      Pop()
      }
    • Inquire_Number()
      }
    • 主程序流程:
      初始化原货架–>用户选择操作–>操作结束
      ###3. 详细设计:
    • 定义商品的结构体:
    typedef int Status;
    typedef struct Elem{
    	char name[50] = { '\0' };//商品名
    	char data[30] = { '\0' };//商品截止日期
    }ElemType;
    
    • 定义顺序栈的基本数据结构:
    #define maxsize 100
    typedef int Status;
    typedef int ElemType;
    typedef struct {//顺序栈数据结构
    	ElemType* base;
    	ElemType* top;
    	int stacksize;
    }SqStack;
    
    • 定义栈的初始化函数:
    Status InitStack(SqStack& S) {//初始化栈
    	S.base = (ElemType*)malloc(maxsize * sizeof(ElemType));
    	if (!S.base) return 0;
    	S.top = S.base;
    	S.stacksize = maxsize;
    }
    
    • 定义入栈函数:
    Status Push(SqStack& S, ElemType e) {//入栈
    	if (S.top-S.base==S.stacksize) return 0;
    	*(S.top++) = e;
    	return 1;
    }
    
    • 定义货架为空时,进货的函数:
      货架为空,直接入栈即可
      注意需判断满
    void Purchase_Product_Empty(SqStack& S,ElemType e,int num) {//货架为空时进货
    	printf("请输入商品名:");
    	scanf_s("%s", e.name,30);
    	printf("请输入商品的截止日期:");
    	scanf_s("%s", e.data, 20);
    	printf("请输入商品数:");
    	scanf_s("%d", &num);
    	while (num--) {
    		if (Push(S, e) == 0) {
    			printf("货架已满,请更换更大的货架!\n");
    			return;
    		}
    	}
    	printf("进货成功!\n");
    }
    
    • 定义货架不为空时,进货的函数:
      先将原货架中商品依次拿出,放入周转货架中,再将新货放入周转货架中,再将周转货架中商品依次取出,放入原货架中。
      假设S代表原货架,S1代表周转货架,操作为S出栈,入S1,新商品入栈S1,S1出栈,入S
      注意判断S,S1在入栈时是否为满
    void Purchase_Product_noEmpty(SqStack& S, SqStack& S1,int num,ElemType m) {//货架不为空时进货
    	InitStack(S1);
    	ElemType e;
    	printf("请输入商品名:");
    	scanf_s("%s", m.name, 30);
    	printf("请输入商品的截止日期:");
    	scanf_s("%s", m.data, 20);
    	printf("请输入商品数:");
    	scanf_s("%d", &num);
    	while (Pop(S,e)) {//放入周转货架
    		Push(S1, e);
    	}
    	while (num--) {//新商品入周转货架
    		if (Push(S1, m) == 0) {
    			printf("周转货架已满,请选用更大的周转货架!\n");
    			return;
    		}
    	}
    	while (Pop(S1, e)) {//周转货架入原货架
    		if (Push(S, e) == 0) {
    			printf("原货架已满,请选用更大的原货架!\n");
    			return;
    		}
    	}
    	printf("进货成功!\n");
    }
    
    • 出售商品:
      用户输入购买商品数,商品出栈,判断是否达到用户购买商品数,若未达到,则让用户选择是否继续购买,若需购买,则该栈变为空栈,若不需购买,则顶部指针返回原位
    void Sell_Product(SqStack& S, int num) {//出售商品
    	ElemType m;
    	ElemType* p = S.top;
    	int a;
    	printf("请选择出售商品数:");
    	scanf_s("%d", &num);
    	while (num--) {
    		if (Pop(S, m) == 0) {
    			printf("商品不足!仅能购买%d个\n", p - S.base);
    			printf("是否还购买商品?\n");
    			printf("1.继续购买\n2.不购买\n");
    			printf("请选择:");
    			scanf_s("%d", &a);
    			if (a == 2) {
    				S.top = p;
    				return;
    			}
    			printf("出售成功!\n");
    			return;
    		}
    	}
    	printf("出售成功!\n");
    }
    }
    
    • 展示当前货架上商品:
      遍历栈,打印当前商品数及商品的名称和日期
    void Inquire_Number(SqStack S) {//展示当前货架商品
    	printf("商品数:%d\n", S.top - S.base);
    	while (S.top != S.base) {
    		S.top--;
    		printf("%s\t\t\t\t%s\n", S.top->name,S.top->data);
    	}
    }
    
    1. 完整代码:
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #define maxsize 100
    typedef int Status;
    typedef struct Elem{
    	char name[50] = { '\0' };
    	char data[30] = { '\0' };
    }ElemType;
    typedef struct {//顺序栈数据结构
    	ElemType* base;
    	ElemType* top;
    	int stacksize;
    }SqStack;
    Status InitStack(SqStack& S) {//初始化栈
    	S.base = (ElemType*)malloc(maxsize * sizeof(ElemType));
    	if (!S.base) return 0;
    	S.top = S.base;
    	S.stacksize = maxsize;
    }
    Status Push(SqStack& S, ElemType e) {//入栈
    	if (S.top - S.base == S.stacksize) return 0;
    	*(S.top++) = e;
    	return 1;
    }
    Status Pop(SqStack& S, ElemType& e) {//出栈
    	if (S.top == S.base) return 0;
    	e = *(--S.top);
    	return 1;
    }
    void Purchase_Product_noEmpty(SqStack& S, SqStack& S1,int num,ElemType m) {//货架不为空时进货
    	InitStack(S1);
    	ElemType e;
    	printf("请输入商品名:");
    	scanf_s("%s", m.name, 30);
    	printf("请输入商品的截止日期:");
    	scanf_s("%s", m.data, 20);
    	printf("请输入商品数:");
    	scanf_s("%d", &num);
    	while (Pop(S,e)) {//放入周转货架
    		Push(S1, e);
    	}
    	while (num--) {//新商品入周转货架
    		if (Push(S1, m) == 0) {
    			printf("周转货架已满,请选用更大的周转货架!\n");
    			return;
    		}
    	}
    	while (Pop(S1, e)) {//周转货架入原货架
    		if (Push(S, e) == 0) {
    			printf("原货架已满,请选用更大的原货架!\n");
    			return;
    		}
    	}
    	printf("进货成功!\n");
    }
    void Sell_Product(SqStack& S, int num) {//出售商品
    	ElemType m;
    	ElemType* p = S.top;
    	int a;
    	printf("请选择出售商品数:");
    	scanf_s("%d", &num);
    	while (num--) {
    		if (Pop(S, m) == 0) {
    			printf("商品不足!仅能购买%d个\n", p - S.base);
    			printf("是否还购买商品?\n");
    			printf("1.继续购买\n2.不购买\n");
    			printf("请选择:");
    			scanf_s("%d", &a);
    			if (a == 2) {
    				S.top = p;
    				return;
    			}
    			printf("出售成功!\n");
    			return;
    		}
    	}
    	printf("出售成功!\n");
    }
    void Inquire_Number(SqStack S) {//展示当前货架商品
    	printf("商品数:%d\n", S.top - S.base);
    	while (S.top != S.base) {
    		S.top--;
    		printf("%s\t\t\t\t%s\n", S.top->name,S.top->data);
    	}
    }
    void Purchase_Product_Empty(SqStack& S,ElemType e,int num) {//货架为空时进货
    	printf("请输入商品名:");
    	scanf_s("%s", e.name,30);
    	printf("请输入商品的截止日期:");
    	scanf_s("%s", e.data, 20);
    	printf("请输入商品数:");
    	scanf_s("%d", &num);
    	while (num--) {
    		if (Push(S, e) == 0) {
    			printf("货架已满,请更换更大的货架!\n");
    			return;
    		}
    	}
    	printf("进货成功!\n");
    }
    int main() {
    	SqStack S, S1;//原货架与周转货架
    	int k,m=0,n=0;
    	ElemType a, b, c;
    	InitStack(S);
    	printf("1.进货\n2.出售\n3.查询商品数\n4.结束\n");
    	printf("请选择:");
    	while (scanf_s("%d", &k) != EOF) {
    		switch (k) {
    		case 1:
    			if (S.top == S.base) {//货架为空
    				Purchase_Product_Empty(S, a, m);
    			}
    			else {
    				Purchase_Product_noEmpty(S, S1, n, b);
    			}
    			break;
    		case 2:
    			Sell_Product(S, m);
    			break;
    		case 3:
    			Inquire_Number(S);
    			break;
    		case 4:
    			return 0;
    		}
    		printf("---------------------\n\n\n");
    		printf("1.进货\n2.出售\n3.查询商品数\n4.结束\n");
    		printf("请选择:");
    	}
    }
    
    展开全文
  • 商品货架管理程序

    2019-05-07 21:45:59
    商品货架管理:商品货架可以看成一个栈,栈顶商品的生产日期最近,上货时,需要倒货架,以保证生产日期较近的商品在较下的位置,用队列和栈最为周转,实现上述管理过程
  • c++栈实现商品货架管理
  • 这是数据结构课程的课后作业拿来和初学者一起分享同学好的代码。商品货架管理,包括文件的读入读出操作,商品的货架管理主要功能实现
  • 数据结构课程设计-商品货架管理(C语言)

    千次阅读 多人点赞 2020-07-10 12:35:31
    数据结构课程设计——商品货架管理(C语言,顺序栈) 一、问题描述 商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。上货时,需要进行倒货架,以保证生产日期较近的商品在较下的位置。 二...

    数据结构课程设计——商品货架管理(顺序栈)

    一、问题描述

    商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。上货时,需要进行倒货架,以保证生产日期较近的商品在较下的位置。

    二、基本要求

    针对一种特定商品,实现上诉管理过程。

    三、实现提示

    用栈模拟货架和周转空间。

    四、源程序

    #include <stdio.h>
    #include <string.h>//字符串 
    #include<time.h>//时间 
    #include<stdlib.h>
    #include <conio.h>
    #include <windows.h>
    #define size 3	//货架最大容量
    //商品信息结构体
    struct Data{
        int year;	//年份
        int month;	//月份
        int day;	//日期
    	int num;	//数量 
    	int data;	//保质期 
    	int num_1; 	//货件编号
    };
    //定义顺序栈 
    typedef struct{
    	struct Data sp[size];//看成数组 
    	int top;//栈顶 
    }seqstack; 
    
    void InitStack(seqstack *S1);
    int StackEmpty(seqstack *S1);
    int StackFull(seqstack *S1);
    void push(seqstack *S1,seqstack *S2);
    void pop(seqstack *S1,seqstack *S2);
    void find(seqstack *S1);
    void Print(seqstack *S1);
    void output(seqstack *S1);
    void print1(seqstack *S1);
    void del(seqstack *S1);
    void save(seqstack *S1);
    void menu();
    
    void InitStack(seqstack *S1){	//栈初始化
    	S1->top=-1;
    }
    int StackEmpty(seqstack *S1){	//判断栈是否空
    	if(S1->top==-1) return 1;
    	else return 0;
    }
    int StackFull(seqstack *S1){	//判断栈是否满
    	if(S1->top==size-1)return 1;
    	else return 0;
    }
    
    void push(seqstack *S1,seqstack *S2){	//商品货件上架(录入商品货件信息)
    	int i,n,m,j=0;
    	time_t t;
       	struct tm * lt;
       	time (&t);//获取Unix时间戳。
       	lt = localtime (&t);//转为时间结构。
    	struct Data p;
    	m=(lt->tm_year+1900)*365+(lt->tm_mon)*30+lt->tm_mday;
    	printf("------------欢迎进入商品上货界面!------------\n\n\n");
    	if(StackFull(S1))printf("\t*货架已满,无法上货!");
    	else{
    	printf("该货架最大容量为%d!,货架已有%d件货物!\n\n",size,S1->top+1);
    	do{
    		fflush(stdin);
    		printf("\n请输入本次上货的件数:");	//超过货架最大容量,重新输入
    		scanf("%d",&n);
    		if(n+S1->top+1>size) printf("\n该货架最大容量为%d且货架已有%d件货物!请重新输入!\n\n",size,S1->top+1);
    	}while(n+S1->top+1>size);  
    	for(j=0;j<n;j++){
    		printf("\n请输入第%d件货物的信息:\n",j+1);
    		printf("\n\to货件编号:");
    		scanf("%d",&p.num_1); 
    	do{
    		fflush(stdin);  	
    		printf("\n\to生产日期:");	//生产日期小于今天且规范,货件为近十年的货件
    		scanf("%d/%d/%d",&p.year,&p.month,&p.day);
    		if((p.year*365+(p.month-1)*30+p.day)>m||p.year<=0||p.year<(lt->tm_year+1890)||p.month<=0||p.month>12||p.day<=0||p.day>30)
    		printf("\n输入的生产日期不对!请重新输入!\n");
    		}while((p.year*365+(p.month-1)*30+p.day)>m||p.year<=0||p.year<(lt->tm_year+1890)||p.month<=0||p.month>12||p.day<=0||p.day>30);
    	do{
    		fflush(stdin);
    		printf("\n\to商品数量:");
    		scanf("%d",&p.num);
    		if(p.num<=0) printf("\n输入的数量不对!请重新输入!\n");
    	}while(p.num<=0);  
    		printf("\n\to保质期(天):");
    		scanf("%d",&p.data);
    		i=1;
    	while(S1->top!=-1&&((p.year*365+(p.month-1)*30+p.day)-(S1->sp[S1->top].year*365+(S1->sp[S1->top].month-1)*30+S1->sp[S1->top].day))>0){		//倒货
    		S2->top++;
    		S2->sp[S2->top]=S1->sp[S1->top];
    		S1->top--;				
    	}
    	S1->top++;
    	S1->sp[S1->top]=p;
    	for(;S2->top>-1;S2->top--){
    		S1->top++;
    		S1->sp[S1->top]=S2->sp[S2->top];
    		} 
    	}
    	if(i==1) printf("\n商品上架成功"); 
     }printf("\n\n\n返回上一层,");
     system("pause");
    system("cls");
    }
    
    void find(seqstack *S1){	//查询界面
    	int n,j;
    	printf("----------欢迎进入商品查询界面!----------\n\n");
    	if(StackEmpty(S1)) printf("\n\t*货架为空,无法查询,请先添加货物!\n"); 	//货架空
    	else{
    	do{
    		printf("\n【按 生产日期 查询输入1】\t【按 数量 查询输入2】\t【退出查询界面输入0】"); 
    		printf("\n\n\n请选择您的选项:");
    		scanf("%d",&n);	
    		switch(n){ 
    			case 1: 
    				{		//按生产日期查询
    				int month,year,day;
      				int i=0; 
    				printf("\n请输入要查询的日期:");
    				scanf("%d/%d/%d",&year,&month,&day); 
    				for(j=S1->top;j>=0;j--){
    				if(S1->sp[j].year==year&&S1->sp[j].month==month&&S1->sp[j].day==day){
    				if(i==0) printf("\n%d年%d月%d日生产的旺仔牛奶如下:\n\n",year,month,day); 	//存在该货件
    				if(i==0) printf("\t货件编号\t生产日期\t保质期(天)\t商品数量\n\n");
    				printf("\t%d",S1->sp[j].num_1); 
    				printf("\t\t%d/%d/%d",S1->sp[j].year,S1->sp[j].month,S1->sp[j].day);
    				printf("\t%d",S1->sp[j].data);
    				printf("\t\t%d",S1->sp[j].num);
    				printf("\n\n");
    				i=1;
    				}
    			}
    				if(i==0) printf("\n\n\t无%d/%d/%d生产的旺仔牛奶!\n",year,month,day);		//无该货件
    				printf("\n\n----------------------------------------\n\n"); 
    				break;
    				}
    			case 2:
    				{int num;		//按数量查询
    				int i=0;
    				printf("\n请输入要查询的数量:");
    				scanf("%d",&num); 
    				for(j=S1->top;j>=0;j--){
    				if(S1->sp[j].num<=num){
    				if(i==0) printf("\n货架上%d件以下的旺仔牛奶如下:\n\n",num);  
    				if(i==0) printf("\t货件编号\t生产日期\t保质期(天)\t商品数量\n\n");		//存在该数量以下的货件
    				printf("\t%d",S1->sp[j].num_1); 
    				printf("\t\t%d/%d/%d",S1->sp[j].year,S1->sp[j].month,S1->sp[j].day);
    				printf("\t%d",S1->sp[j].data);
    				printf("\t\t%d",S1->sp[j].num);
    				printf("\n\n");
    				i=1;
    				}
    			}
    				if(i==0) printf("\n\n\t无%d件以下的旺仔牛奶!\n",num); 		//无此类货件
    				printf("\n----------------------------------------\n\n"); 
    				break;
    			}
    		}
    		}while(n!=0);
    	}printf("\n\n返回上一层,"); 
    	system("pause");
    	system("cls");		
    }
    
    void Print(seqstack *S1){		//货架的货件信息
    	int j;
    	printf("----------欢迎进入货架清单界面!----------\n\n\n");
    	if(StackEmpty(S1)) printf("\t*货架为空,请先添加货物!\n"); 	//货架空
    	else{
    		print1(S1);
    	}
    	printf("\n\n返回上一层,");
    	system("pause");
    	system("cls"); 
    }
    
    void print1(seqstack *S1){
    	int j;
    	printf("货架清单如下:\n\n");
    	printf("\t货件编号\t生产日期\t保质期(天)\t商品数量\n\n");
    	for(j=S1->top;j>=0;j--){
    		printf("\t%d",S1->sp[j].num_1); 
    		printf("\t\t%d/%d/%d",S1->sp[j].year,S1->sp[j].month,S1->sp[j].day);
    		printf("\t%d",S1->sp[j].data);
    		printf("\t\t%d",S1->sp[j].num);
    		printf("\n\n");
    		}
    } 
    
    void pop(seqstack *S1){		//货件出架
    	int j,num_1,num;
    	printf("------------欢迎进入商品出货界面!------------\n\n\n");
    	if(StackEmpty(S1)) printf("\t*货架为空,请先添加货物!\n");	///货架空
    	else{
    		print1(S1);
    		printf("请输入您要出货货件的编号:");
    		scanf("%d",&num_1);
    		for(j=S1->top;j>=0;j--){
    		if(S1->sp[j].num_1==num_1){
    		do{
    			fflush(stdin);		//输入的出货件数需小于该货件原本有的货件数量
    			printf("\n请输入该货件出货数量:");
    			scanf("%d",&num);
    			if(num>S1->sp[j].num)
    			printf("该货件无%d件商品,请重新输入!\n"); 
    			}while(num>S1->sp[j].num);
    		S1->sp[j].num-=num;
    		printf("\n\t出货成功!");
    		if(S1->sp[j].num<20) printf("该货件商品小于20件!\n");	//出货后数量小于20会提示上货
    		break;
    			}
    	}
    	}printf("\n\n返回上一层,"); 
    	system("pause");
    	system("cls");
    } 
    
    void del(seqstack *S1,seqstack *S2){	//删除货件
    	char name[20];
    	int num_1,T,j;
    	struct Data p1;
    	printf("------------欢迎进入商品删除界面!------------\n\n\n");
    	if(StackEmpty(S1)) printf("\t*货架为空,请先添加货物!\n");	//货架空
    	else{
    	print1(S1);
    	printf("请输入您要删除货件的编号:");
    	scanf("%d",&num_1); 
    	for(j=S1->top;j>=0;j--){
    		if(S1->sp[j].num_1==num_1){
    			while(S1->top>j){
    				S2->top++;
    				S2->sp[S2->top]=S1->sp[S1->top];
    				S1->top--;
    			}
    			p1=S1->sp[S1->top];
    			S1->top--;
    			for(;S2->top>-1;S2->top--){
    				S1->top++;
    				S1->sp[S1->top]=S2->sp[S2->top];
    			}
    			printf("\n\n\t该货件删除成功!\n");
    			break;}
    		}
    		}
    	printf("\n\n返回上一层,");
    	system("pause");
    	system("cls"); 
    }
    
    void outdata(seqstack *S1){		//打印过期货件
    	int m,i=0,j;
    	time_t t;
       	struct tm * lt;
       	time (&t);//获取Unix时间戳。
       	lt = localtime (&t);//转为时间结构。
        m=(lt->tm_year+1900)*365+(lt->tm_mon)*30+lt->tm_mday;	//当前系统时间
        if(StackEmpty(S1)) printf("\t*货架为空,请先添加货物!\n");	//货架空
        else{
    	for(j=S1->top;j>=0;j--){
    	if((S1->sp[j].year*365+(S1->sp[j].month-1)*30+S1->sp[j].day+S1->sp[j].data)<m){
    	if(i==0) printf("已过期的旺仔牛奶如下(今日日期为:%d/%d/%d):\n\n",lt->tm_year+1900,lt->tm_mon+1,lt->tm_mday);
    	if(i==0) printf("\t货件编号\t生产日期\t保质期(天)\t商品数量\n\n");
    	printf("\t%d",S1->sp[j].num_1); 
    	printf("\t\t%d/%d/%d",S1->sp[j].year,S1->sp[j].month,S1->sp[j].day);
    	printf("\t%d",S1->sp[j].data);
    	printf("\t\t%d",S1->sp[j].num);
    	printf("\n\n");
    	i=1;
    		}
    	}
    	if(i==0) printf("\n\t货架无过期的旺仔牛奶!\n"); }
    	printf("\n\n返回上一层,");
    	system("pause");
    	system("cls");
    } 
    
    void save(seqstack *S1){	//保存货件信息
    	int i,j;
    	FILE *fp; 
    	if(StackEmpty(S1)) printf("\t*货架为空,请先添加货物!\n");   //货架空
    	else{
    	fp=fopen("goods.txt","w");
    	if(!fp){
    		printf("文件不存在\n");
    		return;
    	}
    	//将商品信息写入文件
        fprintf(fp,"===========================商品信息一览表===========================\n");
        fprintf(fp,"\n");
       	fprintf(fp,"货件编号\t\t生产日期\t\t保质期(天)\t\t商品数量\n\n");
       	for(j=S1->top;j>=0;j--){
    		fprintf(fp,"%d",S1->sp[j].num_1); 
    		fprintf(fp,"\t\t%d/%d/%d",S1->sp[j].year,S1->sp[j].month,S1->sp[j].day);
    		fprintf(fp,"\t\t%d",S1->sp[j].data);
    		fprintf(fp,"\t\t%d",S1->sp[j].num);
    		fprintf(fp,"\n\n");
    		}
        fclose(fp); 	 //把缓冲区内最后剩余的数据输出到内核缓冲区,并释放文件指针
        printf("数据已成功导入文件goods.txt!\n"); 
    	printf("\n                              √保存成功!");
    	}
       	printf("\n\n返回上一层,");
    	system("pause");
    	system("cls");
    } 
    void menu(){
    	printf("\n\n\n");
    	printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳ “旺仔牛奶 ”货架 ┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    	printf("\n\n");
    	system("color DF"); 
    	printf("\t\t\t ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃       请选择您要操作的项目      ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            1 上货               ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            2 出货               ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            3 查询               ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            4 过期货件           ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            5 货架清单           ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            6 删除货件           ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            7 保存操作           ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┃            0 退出系统           ┃\n");
        printf("\t\t\t ┃                                 ┃\n");
        printf("\t\t\t ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    
    }
    int main(){
    	seqstack A,B;
    	InitStack(&A);
    	InitStack(&B);
    //值等于栈顶 
    	int i;
    	do{
    		menu();
    		printf("\n\n");
    		printf("  *请输入您的选择(0 - 6):");
    		scanf("%d",&i);
    		printf("\n\n");
    		switch(i){
    			case 1:push(&A,&B);
    				   	break;  //创建top 
    			case 2:pop(&A);
    					break;
    			case 3:find(&A);
    					break;	
    			case 4:outdata(&A);
    					break;
    			case 5:Print(&A);
    					break;
    			case 6:del(&A,&B);
    					break;
    			case 7:save(&A);
    					break; 
    			case 0:printf("正在退出该系统,欢迎下次使用!\n\n");
    					for(int i=0;i<30;i++){
    						Sleep(150);
    						printf("<<"); 
    					}
    					system("cls");
    					break; 
    			default:
    				printf("请输入正确的选项!\n\n");
    					system("pause");
    					system("cls");;
    					break; 
    		}
    	}while(i!=0);
    	return 0;
    }
    

    五、各功能介绍

    1.上货
    (1)先判断栈是否满
    (2)满,提示货架已满,无法上货,否则,输入需要上货的件数,添加货件的信息,即完成上货

    2.出货
    (1)先判断货件是否空
    (2)空,提醒上货,否则,根据货架清单输入出货货件的编号和数量,完成出货

    3.查询
    (1)先判断栈是否空
    (2)空,提醒上货,否则,根据菜单输入相依编号(1.按生产日期,2.数量,0.退出查询),然后根据需入的编号找相应货件,存在,输出该货件信息,否则,打印“无此商品”

    4.打印过期货件
    (1)先判断栈是否空
    (2)空,提醒上货,否则,看货架是否存在过期货件,输出相应的结果

    5.删除货件
    (1)先判断栈是否空
    (2)空,提醒上货,否则,根据货架信息输入删除货件的编号,删除该货件

    6.打印货架清单
    (1)先判断栈是否空
    (2)空,提醒上货,否则,打印出货架的全部货件信息

    7.保存操作
    (1)先判断货架是否空
    (2)空,提醒上货,否则,保存

    六、程序运行截图

    1.菜单界面
    在这里插入图片描述
    2.录入货件信息
    在这里插入图片描述
    浏览当前输入的货件信息
    在这里插入图片描述
    3.货件出货

    货架为空
    在这里插入图片描述
    出货
    在这里插入图片描述
    出货后货架信息
    在这里插入图片描述
    3.查询货件

    货架为空
    在这里插入图片描述
    按生产日期查询
    在这里插入图片描述
    按数量查询
    在这里插入图片描述

    4.打印过期货件

    货架为空
    在这里插入图片描述
    存在过期货件
    在这里插入图片描述
    无过期货件
    在这里插入图片描述
    5.打印货架清单

    货架为空
    在这里插入图片描述
    货架清单
    在这里插入图片描述
    6.删除货件

    货架为空
    在这里插入图片描述
    删除后的货件
    在这里插入图片描述
    删除后货架清单
    在这里插入图片描述
    7.保存操作

    货架为空
    在这里插入图片描述
    保存成功
    在这里插入图片描述
    在这里插入图片描述
    8.退出系统
    在这里插入图片描述

    展开全文
  • 学号 1308010108 2014-2015 学年 第一学期 数据结构 课程设计报告 题 目 基于栈的商品货架管理的设计 专 业 计算机科学与技术 班 级 姓 名 学 号 指导教师 成 绩 计算机与信息工程系 2014 年 11 月 22 日 计算机与...
  • 商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。 上货时,需要倒货架,以保证生产日期较近的商品在较下的位置。
  • python 商品货架管理 转载请标明去处: [问题描述] 用python语言实现一个栈,商品货架可以看成栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。 上货时,需要倒货架,以保证生产日期较近的商品在较下的...

    python 商品货架管理
    转载请标明去处:https://blog.csdn.net/weixin_44347111/article/details/89526578
    [问题描述]
    用python语言实现一个栈,商品货架可以看成栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。 上货时,需要倒货架,以保证生产日期较近的商品在较下的位置。
    [基本要求]
    针对一种特定商品,实现上述管理过程。要求有漂亮的图形界面展示整个过程。
    [实现提示]
    用栈模拟货架和周转空间。
    [测试数据]
    由学生依据软件工程的测试技术自己确定。注意测试边界数据,如空栈。
    希望大家能看得懂,注意的地方是逆序输出的时候,stack[: : -1]就好

    # 栈的实现 https://blog.csdn.net/xlengji/article/details/82143396
    """
    #1.定义一个栈
    #2.栈初始化
    #3.判栈空
    #4.新元素推进栈
    #5.输出栈中元素
    #6.定义一个主函数,用来输出栈内信息
    """
    #1.定义一个栈
    class Stack(object):
        def __init__(self):
            self.stack = []
            self.result = []
    
    #2.栈初始化
        def InitStack(self):
            return self.stack[::-1]
    
    
    #3.判栈空
        def IsEmpty(self,item):
            if len(self.stack) == 0:
                return self.stack==[]
    
    #4.新元素推进栈
        def Push(self, item):
            """加入元素"""
            return self.stack.append(item)
    
    #5.输出栈中元素
        def Pop(self,number):
            """弹出元素"""
            #此行进行对数据的统计
            rec_number=number
            i=0
            while number:
                self.result.append(self.stack[i])#此行进行result输出
                i+=1
                number-=1
            #此行对数据进行删除,其中j的值可以不用采用递增的办法,因为在删的过程中,所有元素的序列会自动前移
            j=0
            while rec_number:
                self.stack.pop(j)
                rec_number-=1
            return self.stack
    
    
    def main():
        information = Stack()
        print("****************************************************************")
        print("*                 欢迎来到商品管理系统                         *")
        print("*         下面请按照我们的提示来实现您要的服务                 *")
        print("****************************************************************")
        goods_name=input("请输入您要存放商品的名字:")
        nums=int(input("请输入您要输入的信息数量:"))
        rem_num=nums
        i=0
        while nums:
            date=int(input("请输入第%d个商品录入的日期,<日期按照20190101的格式输入>:"%(i+1)))
            information.Push(date)
            nums-=1
            i+=1
        print("商品录入完毕!")
        print("*"*30)
        print("现在货架上的商品日期为:")
        print(information.InitStack())
        print("*" * 30)
        fetch_num=int(input("请输入要取商品的数量:"))
        while True:
            if fetch_num<=len(information.stack):
                information.Pop(fetch_num)
                break
            else:
                print("要取的商品超过了货架有的数量,请重新输入")
            fetch_num=int(input("请重新输入要取商品的数量:"))
    
        print("******************************************")
        print("取出的商品日期有:")
        print(information.result)
        print("******************************************")
        print("取出商品后剩下%d件商品的日期为:"%(rem_num-fetch_num))
        print(information.InitStack())
        print("******************************************")
        print("现在货架还能放下%d件商品"%(fetch_num))
    
        #这里是强制性把栈放满
        while fetch_num:
            add_inf=int(input("请输入要放入新商品的日期<日期按照20190101的格式输入>:"))
            information.Push(add_inf)
            fetch_num-=1
        print("商品上货完毕!")
        print("******************************************")
        print("从货架靠里端到外端的商品的日期为:")
        print(information.InitStack())
        print("******************************************")
    
    
    if __name__=="__main__":
        main()
    
    
    展开全文
  • Word 文档资料 福 建 工 程 学 院 课程设计 课 程 算法与数据结构 题 目 商品货架管理 专 业 计算机类 班 级 1102 座 号 3110307201 姓 名 郑桂萍 2012年 6月 26 日 一要解决的问题 商店货架以栈的方式摆放商品商品...
  • 题目: 商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。上货时,需要倒货架,以保证生产日期较近的商品在较下的位置。用队列和栈作为周转,实现上述管理过程。 代码: #include using ...

    题目:

    商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。上货时,需要倒货架,以保证生产日期较近的商品在较下的位置。用队列和栈作为周转,实现上述管理过程。

    代码:

    #include<iostream>
    using namespace std;
    
    typedef struct StackNode{
    	int date;
    	struct StackNode *next;
    }StackNode,*LinkStack;
    
    int InitStack(LinkStack &S){		//初始化栈 
    	S=NULL;
    	return 1;
    }
    
    int Push(LinkStack &S,int e){		//入栈 
    	StackNode *p=new StackNode;
    	p->date=e;
    	p->next=S;
    	S=p;
    	return 1;
    }
    
    int Pop(LinkStack &S,int &e){		//出栈 
    	if(S==NULL) return 0;
    	e=S->date;
    	StackNode *p=S;
    	S=S->next;
    	delete p;
    	return 1;
    }
    
    int GetTop(LinkStack S){			//取栈顶元素 
    	if(S!=NULL) return S->date;
    }
    
    int Traverse(LinkStack S){			//由栈顶到栈底遍历栈 
    	StackNode *p=S;
    	while(p!=NULL){
    		cout<<p->date<<endl;
    		p=p->next;
    	}
    }
    
    int main()
    {
    	int n,e,f;
    	LinkStack A,B;
    	InitStack(A);		//商品货架 
    	InitStack(B);		//周转商品货架 
    	
    	cout<<"请输入原商品货架的商品数量:";
    	cin>>n;
    	cout<<"请由生产日期“最近到最早”输入“原商品”的生产日期:"<<endl;
    	for(int i=0;i<n;++i){
    		cin>>e;
    		Push(A,e); 
    	}
    	cout<<"原商品货架如下所示:"<<endl;
    	Traverse(A);
    	while(A!=NULL){					//将商品由商品货架转入周转商品货架 
    		Pop(A,e);
    		Push(B,e);
    	}
    	
    	cout<<endl<<"请输入上货商品的数量:";
    	cin>>n;
    	cout<<"请由生产日期“最近到最早”输入“上货商品”的生产日期:"<<endl;
    	for(int i=0;i<n;++i){
    		cin>>e;
    		//将周转货架中商品的生产日期比当前上货商品的生产日期晚的放入商品货架
    		while(B!=NULL&&e<GetTop(B)){
    			Pop(B,f);
    			Push(A,f);
    		}
    		Push(A,e);					//将上货商品放入商品货架 
    	}
    	while(B!=NULL){					//将周转货架中剩余的商品放入商品货架 
    		Pop(B,e);
    		Push(A,e);
    	}
    	cout<<"当前商品货架如下所示:"<<endl;
    	Traverse(A);
    	return 0;
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 商品货架可以看成一个栈,栈顶商品的生产日期最早,栈底商品的生产日期最近。 上货时,需要倒货架,以保证生产日期较近的商品在较下的位置。
  • #define size 4struct data/*定义商品信息*/{char name[6]; /*商品名称*/long int date; /*商品生产日期*/};typedef struct/*定义顺序栈*/{struct data sp[size];int top;}seqstack;int push1(seqstack *s1){int i=0...
  • 数据结构——商品货架管理(C++实现) 源代码

    千次阅读 多人点赞 2018-10-29 19:56:58
    针对一种特定商品,实现上述管理过程 测试数据:由学生自己确定一组测试数据。注意测试边界数据,如空栈。   源代码 #include &lt;iostream&gt; using namespace std; struct stack{ //定...
  • 很实用的程序适用于第一次学 c程序,程序有货架管理可以运行,没有错误
  • 货架销售管理系统》是专门适用于该行业专卖店销售及商品管理的软件,是您的企业进行信息化管理的强大工具。该系统在功能方面主要包括了:基本信息(单位信息、货架信息、供货
  • 本次程序设计旨在通过程序完成商品货架的基本管理,始终保持每一次上货后生产日期越远的商品越靠近栈顶。 本程序对于数据的处理及要求如下: 1.由于定义商品名是用长度为10的数组,故输入商品名切忌超过10个字符。 2...
  • 货架管理系统模拟

    2019-10-08 20:31:47
    用栈来模拟货架管理系统 [问题描述] 商店货架以栈的方式摆放商品。生产日期越近的越靠近栈底,出货时从栈顶取货。一天营业结束,如果货架不满,则需上货。入货直接将商品摆放到货架上,则会使生产日期越近的商品越...
  • 本程序通过出栈入栈的操作实现了商品货架管理。自己建立数据文件的方式对供货信息进行如下管理:①查询②修改③排序。商店货架以栈的形式摆放商品,生产日期越近的越靠近栈底,出栈是从栈顶取货,一天营业结束,...
  • 关键字:货架 管理 货架 联手 推出 系统 Vue公司是单品级RFID解决方案领先供应商,Pricer AB是电子显示与信息系统领先供应商,近日这两个公司宣布与IBM合作为零售业市场开发突破性RFID货架管理系统。...
  • 单位需要接待客人,领导派小张去买大量一次性...大部分的零售企业为了便于管理,就将所有这些商品归入"纸制 品"品类,并陈列在一起。 现代零售业在组织商品的过程中,一般是首先按照商品特征进行大分类,然后按照制...
  • 商品缺货与货架陈列绩效考评适用于超市管理学、超市管理人员、超市职员等学习参考使用,欢迎大家下载商品...该文档为商品缺货与货架陈列绩效考评,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • Vue公司是单品级RFID解决方案领先供应商,Pricer AB是电子显示与信息系统领先供应商,近日宣布与IBM合作为零售业市场开发突破性RFID货架管理系统。 新的解决方案通过RFID实时采集单品级商品数据,使电子货架商品...
  • 2. 实现商品的录入功能 3. 实现查询商品信息功能 4. 实现商品信息修改功能 5. 实现商品信息添加功能 6. 实现商品的删除功能 7. 实现商品的供应与需求情况 二、 扩展功能: 1. 定义用户类型 2. 实现用户登录系统功能...
  • 建立某些商品的需求与库存管理模型,从商品自身的销售弹性与替代品的销售弹性出发,设定摆放量充足时货架摆放量与需求量是指数函数关系;当摆放量小于一定量时,顾客的需求为一常数,并且允许顾客流失和延迟销售;在此基础...
  • 在前面微信小店系列篇《C#开发微信门户及应用(22)-微信小店的开发和使用》...这个模块是在微信小店对象里面,最为复杂,也是最难理解的一个模块,对于它的对象建模,需要反复测试才能完善起来,因此这个货架管理模块...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 187
精华内容 74
关键字:

商品货架管理