[已解决]求助

乔治爱啃脚趾

1．超市内商品的信息包括商品编号和生产日期。用于商品展示的货架，是一个半封闭的货架，客人拿取商品，工作人员上架新的商品，都只能固定在开放的一端进行。当工作人员上架新商品时，需要整理展示架上的商品，使生产日期较早的商品，放在靠近固定开放的一端。请编程模拟对商品展示架中已有商品按生产日期进行整理的过程。
下面是我写的部分代码。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #define stack_init_size 100
   
4. #define stackincrement 10
   
5. #define OK 1
   
6. #define ERROR 0
   
7. typedef int status;
   
8. typedef int selemtype;
   
9. typedef struct{
   
10.         selemtype *base;//栈底指针
    
11.         selemtype *top;//栈顶指针
    
12.         int stacksize;
    
13. }sqstack;
    
14. typedef struct            //声明结构体Production用于表示生产日期
    
15. {   int year;
    
16.     int month;
    
17.     int day;
    
18. }production;
    
19. typedef struct
    
20. {    int  number;                  //商品编号
    
21.          production date;           //商品生产日期
    
22. }Selemtype;
    
23. void initstack(sqstack &s)
    
24. {
    
25.         s.base=(selemtype*)malloc(stack_init_size*sizeof(selemtype));
    
26.         s.top=s.base;
    
27.         s.stacksize=stack_init_size;
    
28. }
    
29. void push(sqstack &s,Selemtype e)//入栈
    
30. {
    
31.         if(s.top-s.base>=s.stacksize){
    
32.                 s.base=(selemtype*)realloc(s.base,(s.stacksize+stack_init_size)*sizeof(selemtype));
    
33.                 if(!s.base)  
    
34.                        printf("error");
    
35.                            s.top=s.base+s.stacksize;
    
36.                            s.stacksize+=stack_init_size;
    
37.         }
    
38.         *s.top=e;
    
39.         s.top++;
    
40. }
    
41. void pop(sqstack &s,selemtype k)//出栈
    
42. {
    
43.         selemtype *e=s.top-1;
    
44.         int i=0;
    
45.         if(s.base==s.top){
    
46.                 printf("栈为空");
    
47.         }
    
48.         k=*e;
    
49.         s.top--;
    
50. }
    
51. status gettop(sqstack s,Selemtype k)//取栈顶元素
    
52. {
    
53.         Selemtype e;
    
54.         if(s.top!=s.base){
    
55.       return k=*(s.top-1);
    
56.         }
    
57.         return ERROR;
    
58. }
    
59. void print(sqstack &s)//输出
    
60. {
    
61.         selemtype *e=s.base;
    
62.         int i=0;
    
63.         while(i<(s.top-s.base))
    
64.         {
    
65.                 printf("%d ",*e);
    
66.                 i++;
    
67.                 e++;
    
68.         }
    
69. }
    
70. status judge(sqstack &s,Selemtype e)//栈顶元素大于输入返回1
    
71. {
    
72.         Selemtype k;
    
73.         gettop(s,k);
    
74.         if(k.date.year>e.date.year){
    
75.                 return OK;
    
76.         }
    
77.         else if(k.date.year==e.date.year){
    
78.                 if(k.date.month>e.date.month){
    
79.                         return OK;}
    
80.                 else if(k.date.month==e.date.month){
    
81.                         if(k.date.day>e.date.day){
    
82.                                 return OK;
    
83.                         }
    
84.                         else if(k.date.day==e.date.day){
    
85.                                 return OK;
    
86.                         }
    
87.                 }
    
88.                 }
    
89.         else {
    
90.                 return ERROR;
    
91.         }
    
92. }
    
93. void Lineup()
    
94. {
    
95.         int i,j=1,t;
    
96.         sqstack s,temp;
    
97.         Selemtype e,k;
    
98.         initstack(s);
    
99.         initstack(temp);
    
100.         while(j!=4)
     
101.         {
     
102.                 printf("1.入库  2.出库  3.查看货物   4.退出\n");
     
103.                 scanf("%d",&j);
     
104.                 if(j==1)
     
105.                 {
     
106.                         printf("请输入商品编号及生产日期：\n");
     
107.                         scanf("%d %d %d %d",&e.number,&e.date.year,&e.date.month,&e.date.day);
     
108.                         if(s.top==s.base)
     
109.                         {
     
110.                                 push(s,e);
     
111.                                 s.top++;
     
112.                         }
     
113.                         else{
     
114.                                         gettop(s,k);
     
115.                                         t=0;
     
116.                                         while(!t){
     
117.                                                 pop(s,k);
     
118.                                                 push(temp,k);
     
119.                                                 t=judge(s,e);
     
120.                                         }
     
121.                                 }
     
122.                         }
     
123.                 }
     
124.         }
     
125. int main()
     
126. {
     
127.         Lineup();
     
128.     return 0;
     
129. }

复制代码

最佳答案

月排行榜 / 总排行榜

Mike_python小

2023-10-31 23:41:50

商品展示架整理

这个问题可以使用栈来解决，每一个商品都是一个元素，存储商品编号和生产日期。根据生产日期的先后顺序，将商品入栈，并在入栈时进行整理，保证生产日期早的商品在栈底，晚的商品在栈顶。另外，为了方便查看货物，可以在出栈时将商品信息输出。

以下是修改过后的代码：

1. ++
2. #include <stdio.h>
3. #include <stdlib.h>
5. #define stack_init_size 100
6. #define stackincrement 10
7. #define OK 1
8. #define ERROR 0
10. typedef int status;
11. typedef struct {
12.     int year;
13.     int month;
14.     int day;
15. } Production;
17. typedef struct {
18.     int number;
19.     Production date;
20. } Element;
22. typedef struct {
23.     Element* base; // 栈底指针
24.     Element* top; // 栈顶指针
25.     int stacksize;
26. } SqStack;
28. void InitStack(SqStack& s) {
29.     s.base = (Element*)malloc(stack_init_size * sizeof(Element));
30.     s.top = s.base;
31.     s.stacksize = stack_init_size;
32. }
34. void Push(SqStack& s, Element e) {
35.     if (s.top - s.base >= s.stacksize) {
36.         s.base = (Element*)realloc(s.base, (s.stacksize + stack_init_size) * sizeof(Element));
37.         if (!s.base) {
38.             printf("error");
39.             return;
40.         }
41.         s.top = s.base + s.stacksize;
42.         s.stacksize += stack_init_size;
43.     }
44.     *s.top = e;
45.     s.top++;
46. }
48. void Pop(SqStack& s, Element& k) {
49.     if (s.top == s.base) {
50.         printf("栈为空\n");
51.         return;
52.     }
53.     s.top--;
54.     k = *(s.top);
55. }
57. status GetTop(SqStack s, Element& k) {
58.     if (s.top != s.base) {
59.         k = *(s.top - 1);
60.         return OK;
61.     }
62.     return ERROR;
63. }
65. void Print(SqStack s) {
66.     Element* e = s.base;
67.     while (e != s.top) {
68.         printf("编号：%d，生产日期：%d-%d-%d\n", e->number, e->date.year, e->date.month, e->date.day);
69.         e++;
70.     }
71. }
73. status Judge(Element a, Element b) {
74.     if (a.date.year < b.date.year) {
75.         return OK;
76.     } else if (a.date.year == b.date.year && a.date.month < b.date.month) {
77.         return OK;
78.     } else if (a.date.year == b.date.year && a.date.month == b.date.month && a.date.day < b.date.day) {
79.         return OK;
80.     } else {
81.         return ERROR;
82.     }
83. }
85. void Lineup() {
86.     int op = 0;
87.     SqStack s;
88.     SqStack temp;
89.     InitStack(s);
90.     InitStack(temp);
91.     while (op != 4) {
92.         printf("1.入库 2.出库 3.查看货物 4.退出\n");
93.         scanf("%d", &op);
94.         switch (op) {
95.             case 1: {
96.                 Element e;
97.                 printf("请输入商品编号及生产日期：\n");
98.                 scanf("%d %d %d %d", &e.number, &e.date.year, &e.date.month, &e.date.day);
99.                 if (s.top == s.base) {
100.                     Push(s, e);
101.                 } else {
102.                     Element k;
103.                     int t = 0;
104.                     while (!t) {
105.                         Pop(s, k);
106.                         Push(temp, k);
107.                         t = Judge(k, e);
108.                     }
109.                     Push(s, e);
110.                     while (temp.top != temp.base) {
111.                         Pop(temp, k);
112.                         Push(s, k);
113.                     }
114.                 }
115.                 break;
116.             }
117.             case 2: {
118.                 Element k;
119.                 Pop(s, k);
120.                 printf("出库：编号：%d，生产日期：%d-%d-%d\n", k.number, k.date.year, k.date.month, k.date.day);
121.                 break;
122.             }
123.             case 3: {
124.                 Print(s);
125.                 break;
126.             }
127.             case 4: {
128.                 printf("谢谢使用！\n");
129.                 break;
130.             }
131.             default: {
132.                 printf("输入有误，请重新输入\n");
133.                 break;
134.             }
135.         }
136.     }
137. }
139. int main() {
140.     Lineup();
141.     return 0;
142. }

复制代码

注意在输入商品信息时，要将商品编号和生产日期分别赋值给结构体中的对应成员。另外，为了方便查看货物，可以增加一个“查看货物”功能，输出所有存放在栈中的商品信息。

球一个最佳答案谢谢啦！这对我非常重要！

跳转到最佳答案楼层

isdkz

你的代码中有一些问题。首先，你定义了一个生产日期的结构体，但在代码中并没有使用到。其次，你定义了一个商品的结构体，但在代码中也没有使用到。最后，在整理货架的过程中，你需要将生产日期较早的商品放在靠近固定开放的一端，但是你的代码中并没有实现这个功能。

下面是我对你的代码进行了修改和补充：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define stack_init_size 100
   
4. #define stackincrement 10
   
5. #define OK 1
   
6. #define ERROR 0
   
7. typedef int status;
   
8. typedef struct {
   
9.     int year;
   
10.     int month;
    
11.     int day;
    
12. } production;
    
13. typedef struct {
    
14.     int number;
    
15.     production date;
    
16. } Selemtype;
    
17. typedef struct {
    
18.     Selemtype *base;
    
19.     Selemtype *top;
    
20.     int stacksize;
    
21. } sqstack;
    
22. 
    
23. void initstack(sqstack &s)
    
24. {
    
25.     s.base = (Selemtype *)malloc(stack_init_size * sizeof(Selemtype));
    
26.     s.top = s.base;
    
27.     s.stacksize = stack_init_size;
    
28. }
    
29. 
    
30. void push(sqstack &s, Selemtype e)
    
31. {
    
32.     if (s.top - s.base >= s.stacksize) {
    
33.         s.base = (Selemtype *)realloc(s.base, (s.stacksize + stack_init_size) * sizeof(Selemtype));
    
34.         if (!s.base) {
    
35.             printf("error");
    
36.         }
    
37.         s.top = s.base + s.stacksize;
    
38.         s.stacksize += stack_init_size;
    
39.     }
    
40.     *s.top = e;
    
41.     s.top++;
    
42. }
    
43. 
    
44. void pop(sqstack &s, Selemtype &k)
    
45. {
    
46.     if (s.base == s.top) {
    
47.         printf("栈为空");
    
48.     }
    
49.     s.top--;
    
50.     k = *s.top;
    
51. }
    
52. 
    
53. status gettop(sqstack s, Selemtype &k)
    
54. {
    
55.     if (s.top != s.base) {
    
56.         k = *(s.top - 1);
    
57.         return OK;
    
58.     }
    
59.     return ERROR;
    
60. }
    
61. 
    
62. void print(sqstack &s)
    
63. {
    
64.     Selemtype *e = s.base;
    
65.     while (e < s.top) {
    
66.         printf("%d ", e->number);
    
67.         e++;
    
68.     }
    
69.     printf("\n");
    
70. }
    
71. 
    
72. status judge(Selemtype k, Selemtype e)
    
73. {
    
74.     if (k.date.year > e.date.year) {
    
75.         return OK;
    
76.     } else if (k.date.year == e.date.year) {
    
77.         if (k.date.month > e.date.month) {
    
78.             return OK;
    
79.         } else if (k.date.month == e.date.month) {
    
80.             if (k.date.day > e.date.day) {
    
81.                 return OK;
    
82.             }
    
83.         }
    
84.     }
    
85.     return ERROR;
    
86. }
    
87. 
    
88. void Lineup()
    
89. {
    
90.     int j = 1;
    
91.     sqstack s, temp;
    
92.     Selemtype e, k;
    
93.     initstack(s);
    
94.     initstack(temp);
    
95.     while (j != 4) {
    
96.         printf("1.入库  2.出库  3.查看货物  4.退出\n");
    
97.         scanf("%d", &j);
    
98.         if (j == 1) {
    
99.             printf("请输入商品编号及生产日期：\n");
    
100.             scanf("%d %d %d %d", &e.number, &e.date.year, &e.date.month, &e.date.day);
     
101.             if (s.top == s.base) {
     
102.                 push(s, e);
     
103.             } else {
     
104.                 while (gettop(s, k) && judge(k, e)) {
     
105.                     pop(s, k);
     
106.                     push(temp, k);
     
107.                 }
     
108.                 push(s, e);
     
109.                 while (temp.top != temp.base) {
     
110.                     pop(temp, k);
     
111.                     push(s, k);
     
112.                 }
     
113.             }
     
114.         }
     
115.     }
     
116. }
     
117. 
     
118. int main()
     
119. {
     
120.     Lineup();
     
121.     return 0;
     
122. }
     

复制代码

在这个修改后的代码中，我增加了对商品结构体的使用，并在入库的过程中实现了按照生产日期进行整理的功能。具体的实现方式是，当有新商品入库时，将栈顶的商品依次弹出并压入临时栈中，直到找到合适的位置插入新商品，然后再将临时栈中的商品重新压回原栈中。

希望对你有帮助！如果还有其他问题，请随时提问。

Mike_python小

商品展示架整理

这个问题可以使用栈来解决，每一个商品都是一个元素，存储商品编号和生产日期。根据生产日期的先后顺序，将商品入栈，并在入栈时进行整理，保证生产日期早的商品在栈底，晚的商品在栈顶。另外，为了方便查看货物，可以在出栈时将商品信息输出。

以下是修改过后的代码：

1. ++
2. #include <stdio.h>
3. #include <stdlib.h>
5. #define stack_init_size 100
6. #define stackincrement 10
7. #define OK 1
8. #define ERROR 0
10. typedef int status;
11. typedef struct {
12.     int year;
13.     int month;
14.     int day;
15. } Production;
17. typedef struct {
18.     int number;
19.     Production date;
20. } Element;
22. typedef struct {
23.     Element* base; // 栈底指针
24.     Element* top; // 栈顶指针
25.     int stacksize;
26. } SqStack;
28. void InitStack(SqStack& s) {
29.     s.base = (Element*)malloc(stack_init_size * sizeof(Element));
30.     s.top = s.base;
31.     s.stacksize = stack_init_size;
32. }
34. void Push(SqStack& s, Element e) {
35.     if (s.top - s.base >= s.stacksize) {
36.         s.base = (Element*)realloc(s.base, (s.stacksize + stack_init_size) * sizeof(Element));
37.         if (!s.base) {
38.             printf("error");
39.             return;
40.         }
41.         s.top = s.base + s.stacksize;
42.         s.stacksize += stack_init_size;
43.     }
44.     *s.top = e;
45.     s.top++;
46. }
48. void Pop(SqStack& s, Element& k) {
49.     if (s.top == s.base) {
50.         printf("栈为空\n");
51.         return;
52.     }
53.     s.top--;
54.     k = *(s.top);
55. }
57. status GetTop(SqStack s, Element& k) {
58.     if (s.top != s.base) {
59.         k = *(s.top - 1);
60.         return OK;
61.     }
62.     return ERROR;
63. }
65. void Print(SqStack s) {
66.     Element* e = s.base;
67.     while (e != s.top) {
68.         printf("编号：%d，生产日期：%d-%d-%d\n", e->number, e->date.year, e->date.month, e->date.day);
69.         e++;
70.     }
71. }
73. status Judge(Element a, Element b) {
74.     if (a.date.year < b.date.year) {
75.         return OK;
76.     } else if (a.date.year == b.date.year && a.date.month < b.date.month) {
77.         return OK;
78.     } else if (a.date.year == b.date.year && a.date.month == b.date.month && a.date.day < b.date.day) {
79.         return OK;
80.     } else {
81.         return ERROR;
82.     }
83. }
85. void Lineup() {
86.     int op = 0;
87.     SqStack s;
88.     SqStack temp;
89.     InitStack(s);
90.     InitStack(temp);
91.     while (op != 4) {
92.         printf("1.入库 2.出库 3.查看货物 4.退出\n");
93.         scanf("%d", &op);
94.         switch (op) {
95.             case 1: {
96.                 Element e;
97.                 printf("请输入商品编号及生产日期：\n");
98.                 scanf("%d %d %d %d", &e.number, &e.date.year, &e.date.month, &e.date.day);
99.                 if (s.top == s.base) {
100.                     Push(s, e);
101.                 } else {
102.                     Element k;
103.                     int t = 0;
104.                     while (!t) {
105.                         Pop(s, k);
106.                         Push(temp, k);
107.                         t = Judge(k, e);
108.                     }
109.                     Push(s, e);
110.                     while (temp.top != temp.base) {
111.                         Pop(temp, k);
112.                         Push(s, k);
113.                     }
114.                 }
115.                 break;
116.             }
117.             case 2: {
118.                 Element k;
119.                 Pop(s, k);
120.                 printf("出库：编号：%d，生产日期：%d-%d-%d\n", k.number, k.date.year, k.date.month, k.date.day);
121.                 break;
122.             }
123.             case 3: {
124.                 Print(s);
125.                 break;
126.             }
127.             case 4: {
128.                 printf("谢谢使用！\n");
129.                 break;
130.             }
131.             default: {
132.                 printf("输入有误，请重新输入\n");
133.                 break;
134.             }
135.         }
136.     }
137. }
139. int main() {
140.     Lineup();
141.     return 0;
142. }

复制代码

注意在输入商品信息时，要将商品编号和生产日期分别赋值给结构体中的对应成员。另外，为了方便查看货物，可以增加一个“查看货物”功能，输出所有存放在栈中的商品信息。

球一个最佳答案谢谢啦！这对我非常重要！

乔治爱啃脚趾

Mike_python小 发表于 2023-10-31 23:41
商品展示架整理

这个问题可以使用栈来解决，每一个商品都是一个元素，存储商品编号和生产日期。根据生产日 ...

你好，我想问问为什么我这个入库后出库是一堆数字

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #define stack_init_size 100
   
4. #define stackincrement 10
   
5. #define OK 1
   
6. #define ERROR 0
   
7. typedef int status;
   
8. typedef struct            //声明结构体Production用于表示生产日期
   
9. {   int year;
   
10.     int month;
    
11.     int day;
    
12. }production;
    
13. typedef struct
    
14. {    int  number;                  //商品编号
    
15.          production date;           //商品生产日期
    
16. }selemtype;
    
17. typedef struct{
    
18.         selemtype *base;//栈底指针
    
19.         selemtype *top;//栈顶指针
    
20.         int stacksize;
    
21. }sqstack;
    
22. void initstack(sqstack &s)
    
23. {
    
24.         s.base=(selemtype*)malloc(stack_init_size*sizeof(selemtype));
    
25.         s.top=s.base;
    
26.         s.stacksize=stack_init_size;
    
27. }
    
28. void push(sqstack &s,selemtype e)//入栈
    
29. {
    
30.         if(s.top-s.base>=s.stacksize){
    
31.                 s.base=(selemtype*)realloc(s.base,(s.stacksize+stack_init_size)*sizeof(selemtype));
    
32.                 if(!s.base)  
    
33.                        printf("error");
    
34.                            s.top=s.base+s.stacksize;
    
35.                            s.stacksize+=stack_init_size;
    
36.         }
    
37.         *s.top=e;
    
38.         s.top++;
    
39. }
    
40. void pop(sqstack &s,selemtype k)//出栈
    
41. {
    
42.         selemtype *e=s.top-1;
    
43.         int i=0;
    
44.         if(s.base==s.top){
    
45.                 printf("栈为空");
    
46.         }
    
47.         k=*e;
    
48.         s.top--;
    
49. }
    
50. status gettop(sqstack s,selemtype k)//取栈顶元素
    
51. {
    
52.         selemtype e;
    
53.         if(s.top!=s.base){
    
54.       k=*(s.top-1);
    
55.           return OK;
    
56.         }
    
57.         return ERROR;
    
58. }
    
59. void print(sqstack &s)//输出
    
60. {
    
61.         selemtype *e=s.base;
    
62.         int i=0;
    
63.         while(i<(s.top-s.base))
    
64.         {
    
65.                 printf("%d ",*e);
    
66.                 i++;
    
67.                 e++;
    
68.         }
    
69. }
    
70. status judge(sqstack &s,selemtype e)//栈顶元素大于输入返回1
    
71. {
    
72.         selemtype k;
    
73.         gettop(s,k);
    
74.         if(k.date.year>e.date.year){
    
75.                 return OK;
    
76.         }
    
77.         else if(k.date.year==e.date.year){
    
78.                 if(k.date.month>e.date.month){
    
79.                         return OK;}
    
80.                 else if(k.date.month==e.date.month){
    
81.                         if(k.date.day>e.date.day){
    
82.                                 return OK;
    
83.                         }
    
84.                         else if(k.date.day==e.date.day){
    
85.                                 return OK;
    
86.                         }
    
87.                 }
    
88.                 }
    
89.         else {
    
90.                 return ERROR;
    
91.         }
    
92. }
    
93. void Lineup()
    
94. {
    
95.         int i,j=1,t;
    
96.         sqstack s,temp;
    
97.         initstack(s);
    
98.         initstack(temp);
    
99.         while(j!=4)
    
100.         {
     
101.                 printf("1.入库  2.出库  3.查看货物   4.退出\n");
     
102.                 scanf("%d",&j);
     
103.                 switch(j){
     
104.                         case 1:{
     
105.                                         selemtype e,k;
     
106.                                         printf("请输入商品编号及生产日期：\n");
     
107.                                    scanf("%d %d %d %d",&e.number,&e.date.year,&e.date.month,&e.date.day);
     
108.                                         if(s.top==s.base)
     
109.                                         {
     
110.                                                 push(s,e);
     
111.                                         }
     
112.                                         else{
     
113.                                                         gettop(s,k);
     
114.                                                         t=0;
     
115.                                                         while(!t){
     
116.                                                                 pop(s,k);
     
117.                                                                 push(temp,k);
     
118.                                                                 t=judge(s,e);
     
119.                                                         }
     
120.                                                         push(s,e);
     
121.                                                         while(temp.base!=temp.top)
     
122.                                                         {
     
123.                                                                 pop(temp,k);
     
124.                                                                 push(s,k);
     
125.                                                         }
     
126.                                                 }
     
127.                                                 break;}
     
128.                         case 2: {
     
129.                                          selemtype k;
     
130.                                      pop(s,k);
     
131.                                          printf("该商品编号为%d,生产日期为%d %d %d",k.number,k.date.year,k.date.month,k.date.day);
     
132.                                          break;}
     
133.                     case 3:{
     
134.                                         print(s);
     
135.                                         break;}
     
136.                 }
     
137.                 }
     
138.         }
     
139. int main()
     
140. {
     
141.         Lineup();
     
142.     return 0;
     
143. }

复制代码