数据结构第二次上鸡

第二次上鸡,搓了好久

问1:搓代码将10进制转化为2进制,要用到栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include<stdio.h>
#include<malloc.h>
#define More 20
#define Init_Size 120
typedef int ElemType;
typedef struct{
ElemType *ebp;
ElemType *esp;
int Size;
}SqStack;

void Init(SqStack &S){
S.ebp=(ElemType*)malloc(Init_Size*sizeof(ElemType));
S.esp=S.ebp;
S.Size=Init_Size;
return;
}

void Get(SqStack &S,ElemType e){
if(S.esp==S.ebp)return;
e=*(S.esp-1);
return;
}

void Push(SqStack &S,ElemType e){
if(S.esp-S.ebp==S.Size){
printf("Th3 5t4ck 1s fu11!\n");
S.ebp=(ElemType*)realloc(S.ebp,sizeof(ElemType)*(S.Size+More));
S.Size+=More;
}
*(S.esp++)=e;
//printf("Pu5h 5ucc3553d,e=%d\n",e);
return;
}

void Pop(SqStack &S,ElemType &e){//e来返回值
if(S.esp==S.ebp){
return;
}
e=*(--S.esp);
return;
}


void Conversion(SqStack &S,int x){
int a,b,y=x;
while(y!=1){
a=y/2;
b=y%2;
Push(S,b);
y=a;
//printf("b=%d,y=%d\n",b,y);
}
//printf("F1n15h3d,esp-ebp=%d\n",S.esp-S.ebp);
return;
}

int IfEmpty(SqStack S){
if(S.ebp==S.esp){
//printf("esp-ebp=%d,3mpty!\n",S.esp-S.ebp);
return 1;
}
else{
//printf("N0t 3mpty!\n");
return 0;
}
}
int main(){
int x,e,i;
SqStack S;
Init(S);
printf("请输入一个10进制数:\n");
scanf("%d",&x);
Conversion(S,x);
while(IfEmpty(S)!=1){
Pop(S,i);
printf("%d",i);
}
}

关于引用和解引用

在c中有解引用的用法,对于一个指针p,p表示对p进行”解释”,通俗来说就是取值的意思。而相对应的,&还有脱去解引用的意思,比如对于指针L,&*L表示L先取值,再用&脱去解引用,所以结果还是地址的意思。。。。

问2:括号匹配问题

设一个表达式中可以包含三种括号:“(”和“)”、“[”和“]”、“{”和“}”,并且这三种括号可以按照任意的次序嵌套使用,考查表达式中的括号是否匹配。
【基本要求】
写一个程序,判断给定表达式中的括号是否匹配。
【测试数据】
有多个表达式,每个表达式(不超过100个字符)占一行。例如,
[(d+f)*{}2]
[(2+3))
()}
[4(6]7)9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;

typedef struct{
ElemType * esp;
ElemType * ebp;
int size;
} Stack;

void Init(Stack &S){
S.ebp=(ElemType*)malloc(sizeof(ElemType)*50);
S.esp=S.ebp;
S.size=50;
return;
}

void Push(Stack &S,ElemType e){
if(S.esp-S.ebp==S.size){
S.ebp=(ElemType*)realloc(S.ebp,sizeof(ElemType)*(20+S.size));
S.size+=20;
}
*(S.esp++)=e;
return;
}

void Get(Stack S,ElemType &e){
if(S.esp==S.ebp){return;}
e=*(--S.esp);
//printf("Get:%c\n",e);
return;
}

void Pop(Stack &S,ElemType &e){
if(S.esp==S.ebp){
return;
}
e=*(--S.esp);
return;
}

int Pair(char a,char b){
if(a=='('){
if(b==')'){return 1;}
}
if(a=='['){
if(b==']'){return 1;}
}
if(a=='{'){
if(b=='}'){return 1;}
}
else{return 0;}
}

int Match(char a[],int len,Stack &S){
int i;
char e;
char l1='(',l2='[',l3='{',r1=')',r2=']',r3='}';
for(i=0;i<len;i++){
if(a[i]==l1||a[i]==l2||a[i]==l3){
Push(S,a[i]);
}
else if(a[i]==r1||a[i]==r2||a[i]==r3){
Get(S,e);
if(Pair(e,a[i])){
Pop(S,e);
}
else{
return 0;
}
}
}
if(S.esp==S.ebp){
//printf("wtf?\n");
return 1;
}
if(S.ebp!=S.esp){
return 0;
}
}
/*int main(){
Stack S;
Init(S);
char x;
Push(S,'1');
Push(S,'2');
Push(S,'3');
Get(S,x);
printf("%c\n",x);
Pop(S,x);
printf("%c\n",x);
Pop(S,x);
printf("%c\n",x);
}*/
int main(){
Stack S;
Init(S);
int i,len;
char a[50];
Init(S);
printf("输入字符串长度:\n");

a1: scanf("%d",&len);
if(len>50){
printf("请输入<=50的数字:\n");
goto a1;
}
printf("请输入字符:\n");
for(i=0;i<len;i++){
getchar();
scanf("%c",&a[i]);
printf("请继续输入:\n",i);
}
if(Match(a,len,S)==1){
printf("yes\n");
}
else{
printf("no\n");
}
/*else{
printf("no\n");
}*/
/*for(i=0;i<len;i++){
printf("%c",a[i]);
}*/
}

问3:停车场问题

【问题描述】
设停车场是一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),若车场内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入。当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其他车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。
【基本要求】
以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项:汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为:若是车辆到达,则输出汽车在停车场内或便道上的停车位置,若是车辆离去,则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。栈以顺序结构实现,队列以链表结构实现。
【测试数据】
设n=2,输入数据为:(‘A’,1,5), (‘A’,2,10), (‘D’,1,15),(‘A’,3,20),(‘A’,4,25),(‘A’,5,30),(‘D’,2,35),(‘D’,4,40),(‘E’,0,0)。其中:’A’表示到达(Arrival);’D’表示离去(Departure);’E’表示输入结束(End)。
【实现提示】
需另设一个栈,临时停放为给要离去的汽车让路而从停车场退出来的汽车,也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中的每个元素表示一辆汽车,包含两个数据项:汽车的牌照号码和进入停车场的时刻

草,这题咋有点超出我的能力范围

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int Status;

typedef struct Car1{
int number;
int arrive_time;
}CarNode;

typedef struct{
CarNode *ebp;
CarNode *esp;
int stacksize;
}Park;

typedef struct Car2{
int number,arrive_time;
struct Car2 *next;
}*CarPtr;

typedef struct{
CarPtr front;
CarPtr rear;
int length;
}Shortcut;

int SInit(Park &P){
P.ebp=(CarNode*)malloc(5*sizeof(Car1));
if(!P.ebp) exit(-2);
P.esp=P.ebp;
P.stacksize=0;
return 1;
}

int Push(Park &P,CarNode e){
*P.esp++=e;
++P.stacksize;
return 1;
}

int Pop(Park &P,CarNode &e){
if(P.esp==P.ebp)
printf("Th3 p@rk1ng lot 1s 3mpty!\n");
else{
e=*--P.esp;
P.stacksize--;
}
return 1;
}

int InitQueue(Shortcut &S){
S.front=S.rear=(CarPtr)malloc(sizeof(Car2));
if(!S.front||!S.rear) exit(-2);
S.front->next=NULL;
S.length=0;
return 1;
}

int EnQueue(Shortcut &S,int number,int arrive_time){
CarPtr p;
p=(CarPtr)malloc(sizeof(Car2));
if(!p) exit(-2);
p->number=number;
p->arrive_time=arrive_time;
p->next=NULL;
S.rear->next=p;
S.rear=p;
++S.length;
return 1;
}

int DeQueue(Shortcut &S,CarPtr &w){
if(S.length == 0)
printf("Th3 s1d3w@y 1s 3mpty!\n");
else{
w = S.front->next;
S.front->next=S.front->next->next;
--S.length;
}
return 1;
}

int Arrival(Park &P,Shortcut &S){
int number,arrive_time;
printf("请输入车牌号:");
scanf("%d",&number);
printf("请输入进场时刻:");
scanf("%d",&arrive_time);
if(P.stacksize<5){
CarNode c;
c.number=number;
c.arrive_time=arrive_time;
Push(P,c);
printf("该车停在%d号车位.\n",P.stacksize);
}
else{
EnQueue(S,number,arrive_time);
printf("停车场已满,停在便道的第%d个位置.\n",S.length);
}
return 1;
}

int Leave(Park &P,Park &P1,Shortcut &S){
int number,le_time,flag=1,money,arrive_time;
printf("请输入车牌号:");
scanf("%d",&number);
printf("请输入离开时刻:");
scanf("%d",&le_time);
CarNode e,m;
CarPtr w;
while(P.stacksize){
Pop(P,e);
if(e.number==number){
flag=0;
money=(le_time-e.arrive_time)*2;
arrive_time=e.arrive_time;
break;
}
Push(P1,e);
}
while(P1.stacksize){
Pop(P1,e);
Push(P,e);
}
if (flag == 0){
if(S.length!=0){
DeQueue(S,w);
m.arrive_time=le_time;
m.number=w->number;
Push(P,m);
free(w);
printf("车牌号为%d的车从便道进入停车场\n",m.number);
}
printf("停车费%d, 占用车位数%d\n",money,P.stacksize);
}
else{
printf("停车场不存在牌号为%d的车\n", number);
}
return 1;
}

int main(){
int m=1;
char flag;
Park P,Q;
Shortcut S;
SInit(P);
SInit(Q);
InitQueue(S);
while(m){
printf("请选择(A(arrive),D(depature),E(end)): ");
scanf("%c",&flag);
switch(flag){
case 'A':
case 'a':
Arrival(P,S);break;
case 'D':
case 'd':
Leave(P,Q,S);break;
case 'E':
case 'e':
m=0;
break;
default:
printf("3rr0r!Please 1nput ag@1n\n");
break;
}
while (flag != '\n')
scanf("%c",&flag);
}
}

数据结构第二次上鸡
https://bl4zygao.github.io/2021/10/08/数据结构第二次上鸡/
Author
bl4zy
Posted on
October 8, 2021
Licensed under