严蔚敏版《数据结构 （C语言版）》和《数据结构题集》（五）——栈和队列...
2024-05-25 22:12:30
栈的顺序表实现
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 1024
5 using namespace std;
6 typedef int Elemtype;
7 typedef struct {
8 Elemtype data[MAXSIZE];
9 int top;
10 }Seqstack;
11 void initSeqstack(Seqstack &s){
12 s.top=-1;
13 }
14 int stackEmpty(Seqstack &s){
15 return s.top==-1;
16 }
17 int SeqstackPush(Seqstack &s,Elemtype e){
18 if (s.top>=MAXSIZE-1)
19 return 0;
20 else {
21 s.top++;
22 s.data[s.top]=e;
23 return 1;
24 }
25 }
26 int SeqstackPop(Seqstack &s,Elemtype &e){
27 if (s.top==-1)
28 return 0;
29 else {
30 e=s.data[s.top];
31 s.top--;
32 return 1;
33 }
34 }
35 void getTop(Seqstack &s,Elemtype &e){
36 e=s.data[s.top];
37 }
38 void displaySeqstack(Seqstack &s){
39 for (int i=0;i<=s.top;i++)
40 printf("%d ",s.data[i]);
41 printf ("\n");
42 }
43 int main()
44 {
45 Seqstack s;Elemtype e;
46 initSeqstack(s);
47 for (int i=1;i<6;i++)
48 SeqstackPush(s,i);
49 displaySeqstack(s);
50 getTop(s,e);
51 printf ("%d\n",e);
52 SeqstackPop(s,e);
53 displaySeqstack(s);
54
55
56 return 0;
57 }严蔚敏版 栈的实现
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define STACK_INIT_SIZE 100
5 #define STACKINCREMENT 10
6 #define OVERFLOW -2
7 using namespace std;
8
9 typedef int Elemtype;
10 typedef struct {
11 Elemtype *base;
12 Elemtype *top;
13 int stacksize;
14 }Seqstack;
15 int initStack(Seqstack &s){
16 s.base=(Elemtype *)malloc(sizeof(Elemtype)*STACK_INIT_SIZE);
17 if (!s.base ) exit(OVERFLOW);//存储分配失败
18 s.top=s.base;
19 s.stacksize=STACK_INIT_SIZE;
20 return 1;
21 }
22 int stackEmpty(Seqstack &s){
23 return s.top==s.base;
24 }
25 int stackLength(Seqstack &s){
26 return s.top-s.base;
27 }
28 int SeqstackPush(Seqstack &s,Elemtype e){
29 if (s.top-s.base >=s.stacksize){
30 s.base=(Elemtype *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(Elemtype));
31 if (!s.base) exit(OVERFLOW);
32 s.top=s.base+s.stacksize;
33 s.stacksize+=STACKINCREMENT;
34 //上溢后：
35 //1.分配存储空间给base指针 2、判断是否分配成功 3、top/stacksize重新修改正确
36 }
37 *s.top=e;
38 s.top++;//或者可以合成*s.top++=e,先赋值再++
39 return 1;
40 }
41 int SeqstackPop(Seqstack &s,Elemtype &e){
42 if(s.top==s.base){
43 printf ("null");
44 return 0;
45 }
46 s.top--;
47 e=*s.top;
48 return 1;
49 }
50 void getTop(Seqstack &s,Elemtype &e){
51 if (s.base!=s.top){
52 e=*--s.top;
53 }
54 }
55 void displaySeqstack(Seqstack &s){
56 for (int i=0;i<=s.top-s.base;i++)
57 printf("%d ",s.base[i]);
58 printf ("\n");
59 }
60
61 int main()
62 {
63 Seqstack s;
64 initStack(s);
65 for (int i=1;i<6;i++)
66 SeqstackPush(s,i);
67 displaySeqstack(s);
68 Elemtype e;
69 getTop(s,e);
70 printf ("%d\n",e);
71 SeqstackPop(s,e);
72 displaySeqstack(s);
73
74
75 return 0;
76 }建立链栈
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define OVERFLOW -2
5 using namespace std;
6 typedef int Elemtype;
7 typedef struct node {
8 Elemtype data;
9 struct node *next;
10 }node,*linkstack;
11 void initLinkstack(linkstack &top){
12 top=NULL;//无头节点的链栈
13 }
14 int linkstackEmpty(linkstack &top){
15 return top==NULL;
16 }
17 int linkstackPush(linkstack &top,Elemtype e){
18 linkstack p=(linkstack )malloc (sizeof(node));
19 if (!p) exit(OVERFLOW);
20 p->data=e;
21 p->next=top;
22 top=p;
23 return 1;
24 }
25 int linkstackPop(linkstack &top,Elemtype &e){
26 e=top->data;
27 linkstack p=top;
28 top=top->next;
29 free(p);
30 return 1;
31 }
32 void getTop(linkstack &top,Elemtype &E){
33 E=top->data;
34 }
35 void displaylinkstack(linkstack &top){
36 linkstack p=top;
37 while (p){
38 printf ("%d ",p->data);
39 p=p->next;
40 }
41 printf ("\n");
42 }
43 int main()
44 {
45 linkstack top;
46 initLinkstack(top);
47 for (int i=1;i<6;i++)
48 linkstackPush(top,i);
49 displaylinkstack(top);
50 Elemtype e;
51 getTop(top,e);
52 printf ("%d\n",e);
53 linkstackPop(top,e);
54 displaylinkstack(top);
55
56
57 return 0;
58 }栈的应用
1.数制转换：对于输入的非负十进制整数，打印输出与之等值的八进制数。
1 //算法3.1
2 void conversion(){
3 Seqstack s;
4 initSeqstack(s);
5 int n;
6 cout<<"请输入一个十进制数字"<<endl;
7 cin>>n;
8 while (n){
9 int r=n%8;
10 SeqstackPush(s,r);
11 n=n/8;
12 }
13 displaySeqstack(s);
14 }2.括号匹配检验
只有【】（）两种括号，检查括号是否是匹配的。
输入一个字符：
1、左括号：压栈
2、右括号：如果栈为空，则右括号多了，输出不匹配信息；如果栈不为空，取出栈顶元素进行配对，如果配对成功弹栈，如果不成功则输出括号不匹配信息。
字符输入结束：
如果栈不为空，左括号多了，输出不匹配信息；否则输出终于匹配信息！
1 int match(){
2 Seqstack s;
3 initSeqstack(s);
4 char c;Elemtype e;
5 scanf ("%c",&c);
6 while (c!='#'){
7 if (c=='['||c=='(')
8 SeqstackPush(s,c);
9 else if (c==']'||c==')'){
10 if (!stackEmpty(s)){
11 e=getTop(s);
12 if (e=='['&&c==']'||e=='('&&c==')'){
13 SeqstackPop(s,e);
14 }
15 }else
16 printf ("右括号太多了！\n");
17 }else
18 printf ("输入符号有误！\n");
19
20 scanf ("%c",&c);
21 }
22 if (!stackEmpty(s))
23 printf ("左括号太多！\n");
24 else
25 printf ("成功匹配");
26 }3.行编辑程序
1 void lineEdit(){
2 Seqstack s;
3 initSeqstack(s);
4 char c;
5 cout<<"输入字符吧！\n"<<endl;
6 cin>>c;
7 while (c!='\n'){
8 switch (c){
9 case '#':SeqstackPop(s);break;
10 case '@':clearstack(s);break;
11 default:SeqstackPush(s,c);
12 }
13 c=getchar();
14 }
15 displaySeqstack(s);
16
17 }顺序队列的基本实现
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 1024
5 using namespace std;
6 typedef int Elemtype;
7 typedef struct{
8 Elemtype data[MAXSIZE];
9 int rear,front;
10 }Seqqueue;
11 void initSeqqueue(Seqqueue &q){
12 q.rear=q.front=-1;
13 }
14 int emptySeqqueue(Seqqueue &q){
15 return q.rear==q.front;
16 }
17 int enSeqqueue(Seqqueue &q,Elemtype e){
18 //先判断是否栈满
19 if (q.rear-q.front>=MAXSIZE){
20 printf ("full!\n");
21 return 0;
22 }
23 q.rear++;
24 q.data[q.rear]=e;
25 return 1;
26 }
27 int deSeqqueue(Seqqueue &q,Elemtype &e){
28 if (emptySeqqueue(q)){
29 printf ("null!\n");
30 return 0;
31 }
32 q.front++;
33 e=q.data[q.front];
34 return 1;
35 }
36 Elemtype getFront(Seqqueue &q){
37 if (emptySeqqueue(q)){
38 printf ("null!\n");
39 }
40 else {
41 Elemtype e;
42 e=q.data[q.front++];
43 return e;
44 }
45 }
46 void display(Seqqueue &q){
47 if (emptySeqqueue(q)){
48 printf ("null!\n");
49 }
50 else {
51 int i=1+q.front;
52 while (i<=q.rear){
53 printf ("%d ",q.data[i]);
54 i++;
55 }
56 printf ("\n");
57 }
58 }
59 int main()
60 {
61 Seqqueue q;
62 initSeqqueue(q);
63 for (int i=1;i<6;i++)
64 enSeqqueue(q,i);
65 display(q);
66 Elemtype e;
67 deSeqqueue(q,e);
68 printf ("%d\n",e);
69 e=getFront(q);
70 printf ("%d\n",e);
71
72
73 return 0;
74 }//1.用两个栈，一个s1,一个s2,来模拟一个队列。队列是先进先出，栈是先进后出，用两个栈模拟一个队列
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 1024
5 using namespace std;
6 //1.用两个栈，一个s1,一个s2,来模拟一个队列。队列是先进先出，栈是先进后出，用两个栈模拟一个队列
7 //2.一带头结点的循环链表表示队列，设计出队入队的算法。
8 //3.用一个数组建两个栈。建两个以上的栈最好用链栈，每一个都是一个栈。
9 //因为用数组建两个栈可以，不能建多个栈
10 //4.队列的题目已经上传。
11
12 typedef int Elemtype;
13 typedef struct {
14 Elemtype data[MAXSIZE];
15 int top;
16 }Seqstack;
17 void initSeqstack(Seqstack &s){
18 s.top=-1;
19 }
20 int isempty(Seqstack &s){
21 return s.top==-1;
22 }
23 int push(Seqstack &s,Elemtype e){
24 if (s.top>=MAXSIZE-1){
25 printf ("full\n");
26 return 0;
27 }
28 s.top++;
29 s.data[s.top]=e;
30 return 1;
31 }
32 int pop(Seqstack &s,Elemtype &e){
33 if (s.top==-1){
34 printf ("null\n");
35 return 0;
36 }
37 e=s.data[s.top];
38 s.top--;
39 return 1;
40 }
41 Elemtype gettop(Seqstack &s){
42 return s.data[s.top];
43 }
44 //入队，直接进1号栈；出队，先判断2号栈是否有元素，有元素就直接弹出栈顶即队首，如果2号栈没有元素，则将1号栈的元素顺序弹出并进2号栈。
45 typedef struct {
46 Seqstack s1;//数据输入栈
47 Seqstack s2;//数据缓存栈，便于先存放进去的元素先出来
48 }dulstack;
49 void initDulstack(dulstack &d){
50 initSeqstack(d.s1);
51 initSeqstack(d.s2);
52 }
53 int enterQueue(dulstack &d,Elemtype x){
54 Elemtype e;
55 if (isempty(d.s1)){
56 //如果S1栈为空，应当把S2栈中的元素全部弹出压入该栈
57 while (!isempty(d.s2)){
58 pop(d.s2,e);
59 push(d.s1,e);
60 }
61 }
62 push(d.s1,x);
63 return 1;
64 }
65 int deQueue(dulstack &d,Elemtype &x){
66 Elemtype e;
67 if (!isempty(d.s2)){
68 x=gettop(s2);
69 return 1;
70 }
71 while (!isempty(d.s1)){
72 pop(d.s1,e);
73 push(d.s2,e);
74 }
75 pop(d.s2,x);
76 return 1;
77 }
78 int isemptydulQueue(dulstack d){
79 return isempty(d.s1)&&isempty(d.s2);
80 }
81
82
83 int main()
84 {
85 dulstack d;
86 initDulstack(d);
87 Elemtype x;
88 scanf ("%d",&x);
89 while (x!=-999){
90 enterQueue(d,x);
91 scanf ("%d",&x);
92 }
93 while (!isemptydulQueue(d)){
94 deQueue(d,x);
95 printf ("%d ",x);
96 }
97 cout<<endl;
98 return 0;
99 }//2.一带头结点的循环链表表示队列，设计出队入队的算法。
1 typedef int Elemtype;
2 typedef struct node {
3 Elemtype data;
4 struct node *next;
5 }node,*Queueptr;
6 typedef struct {
7 Queueptr front ;
8 Queueptr rear;
9 }linkQueue;
10 int initQueue(linkQueue &q){
11 Queueptr lq=(Queueptr)malloc(sizeof(node));
12 if (!lq) exit(OVERFLOW);
13 lq->next=NULL;
14 q.front=q.rear=lq;
15 }
16 int isempty(linkQueue q){
17 return q.front==q.rear;
18 }
19 int enterQueue(linkQueue &q,Elemtype e){
20 Queueptr p=(Queueptr)malloc(sizeof(node));
21 if (!p) exit(OVERFLOW);
22 p->data=e;
23 p->next=q.rear->next;
24 q.rear->next=p;
25 q.rear=p;
26 return 1;
27 }
28 int deQueue(linkQueue &q,Elemtype &e){
29 //出队依旧要判空，入队不需要判满了
30 if (q.rear==q.front){
31 printf("null\n");
32 return 0;
33 }
34 Queueptr p=q.front->next;
35 e=p->data;
36 q.front->next=p->next;
37 //这里要特别注意如果链表中唯一的元素要出队，尾指针必须要重新指向头结点，不然丢失该指针了
38 if (q.front->next==NULL){//或者q.rear==p;
39 q.rear=q.front;
40 }
41 free(p);
42 return 1;
43 }
44
45 int main()
46 {
47 linkQueue q;
48 initQueue(q);
49 Elemtype e;
50 scanf ("%d",&e);
51 while (e!=-999){
52 enterQueue(q,e);
53 scanf ("%d",&e);
54 }
55 while (!isempty(q)){
56 deQueue(q,e);
57 printf ("%d ",e);
58 }
59 cout<<endl;
60 return 0;
61 }用两个队列建立一个栈
/两个队列模拟一个堆栈/
/*队列A、B
入栈：将元素依次压入到非空的队列，第一个元素压倒对列A
出栈：把队列A的前n-1个元素倒到队列B，把第n个元素去掉。此时数据在B中，下次操作，则对B操作。
栈顶：把队列A的前n-1个元素倒到队列B，把第n个元素作为栈顶*/
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 1024
5 #define OVERFLOW -2
6 using namespace std;
7
8 typedef int Elemtype;
9 typedef struct node {
10 Elemtype data;
11 struct node *next;
12 }node,*Queueptr;
13 typedef struct {
14 Queueptr front ;
15 Queueptr rear;
16 }linkQueue;
17 int initQueue(linkQueue &q){
18 Queueptr lq=(Queueptr)malloc(sizeof(node));
19 if (!lq) exit(OVERFLOW);
20 lq->next=NULL;
21 q.front=q.rear=lq;
22 }
23 int isempty(linkQueue q){
24 return q.front==q.rear;
25 }
26 int enterQueue(linkQueue &q,Elemtype e){
27 Queueptr p=(Queueptr)malloc(sizeof(node));
28 if (!p) exit(OVERFLOW);
29 p->data=e;
30 p->next=q.rear->next;
31 q.rear->next=p;
32 q.rear=p;
33 return 1;
34 }
35 int deQueue(linkQueue &q,Elemtype &e){
36 //出队依旧要判空，入队不需要判满了
37 if (q.rear==q.front){
38 printf("null\n");
39 return 0;
40 }
41 Queueptr p=q.front->next;
42 e=p->data;
43 q.front->next=p->next;
44 //这里要特别注意如果链表中唯一的元素要出队，尾指针必须要重新指向头结点，不然丢失该指针了
45 if (q.front->next==NULL){//或者q.rear==p;
46 q.rear=q.front;
47 }
48 free(p);
49 return 1;
50 }
51 int getlength(linkQueue &lq){
52 Queueptr p=lq.front->next;
53 int count=0;
54 while (p!=NULL){
55 count++;
56 p=p->next;
57 }
58 return count;
59 }
60 typedef struct {
61 linkQueue q1;
62 linkQueue q2;
63 }dulQueue;
64 void initDulQueue(dulQueue &dq){
65 initQueue(dq.q1);
66 initQueue(dq.q2);
67 }
68 int isemptyDul(dulQueue dq){
69 return isempty(dq.q1)&&isempty(dq.q2);
70 }
71 int pushDul(dulQueue &dp,Elemtype e){
72 if (isempty(dp.q2)){
73 enterQueue(dp.q1,e);
74 }
75 if (isempty(dp.q1)){
76 enterQueue(dp.q2,e);
77 }
78 return 1;
79 }
80 int popDul(dulQueue &dp,Elemtype &x){
81 Elemtype e;
82 if (isempty(dp.q2)){
83 int count=getlength(dp.q1);
84 for (int i=0;i<count-1;i++){
85 deQueue(dp.q1,e);
86 enterQueue(dp.q2,e);
87 }
88 if (isempty(dp.q1)){
89 //如果这时Q1弹出了最后一个元素
90 deQueue(dp.q2,x);
91 }else
92 deQueue(dp.q1,x);
93 return 1;
94 }
95 if (isempty(dp.q1)){
96 int count=getlength(dp.q2);
97 for (int i=0;i<count-1;i++){
98 deQueue(dp.q2,e);
99 enterQueue(dp.q1,e);
100 }
101 deQueue(dp.q2,x);
102 return 1;
103 }
104 }
105 int main()
106 {
107 dulQueue dq;
108 initDulQueue(dq);
109 Elemtype e;
110 scanf ("%d",&e);
111 while (e!=-999){
112 pushDul(dq,e);
113 scanf ("%d",&e);
114 }
115 while (!isemptyDul(dq)){
116 popDul(dq,e);
117 printf ("%d ",e);
118 }
119 cout<<endl;
120 return 0;
121 }用一个数组建立两个栈
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 20
5 #define OVERFLOW -2
6 using namespace std;
7
8 typedef int Elemtype;
9 typedef struct {
10 Elemtype data[MAXSIZE];
11 int top[2];
12 }Seqstack;
13 void initSeqstack(Seqstack &s){
14 s.top[0]=-1;
15 s.top[1]=MAXSIZE;
16 }
17 int isempty(Seqstack s,int i){
18 if (i==0)
19 return s.top[i]==-1;
20 else
21 return s.top[i]==MAXSIZE;
22 }
23 int isfull(Seqstack s){
24 return s.top[0]+1==s.top[1];
25 }
26 int push(Seqstack &s,Elemtype e,int i){
27 //用int i来判断用户想要push进0栈还是1栈
28 if (isfull(s)){
29 printf("full!\n");
30 return 0;
31 }
32 if (i==0)
33 s.top[i]++;
34 else
35 s.top[i]--;
36 s.data[s.top[i]]=e;
37 return 1;
38 }
39 int pop(Seqstack &s,Elemtype &e,int i){
40 if (isempty(s,i)){
41 printf ("null\n");
42 return 0;
43 }
44 e=s.data[s.top[i]];
45 if (i==0)
46 s.top[i]--;
47 else
48 s.top[i]++;
49 return 1;
50 }
51 int main()
52 {
53 Seqstack s;
54 initSeqstack(s);
55 int x,i;
56 scanf ("%d %d",&x,&i);
57 while (x!=-999){
58 push(s,x,i);
59 scanf ("%d %d",&x,&i);
60 }
61 for (i=0;i<2;i++){
62 while (!isempty(s,i)){
63 pop(s,x,i);
64 printf ("%d ",x);
65 }
66 cout<<endl;
67
68 }
69
70
71
72 return 0;
73 }顺序循环队列
1 #include <iostream>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #define MAXSIZE 8
5 #define OVERFLOW -2
6 using namespace std;
7
8 typedef int Elemtype;
9 typedef struct{
10 Elemtype data[MAXSIZE];
11 int rear,front;
12 }Seqqueue;
13 void initSeqqueue(Seqqueue &q){
14 q.rear=q.front=-1;
15 }
16 int emptySeqqueue(Seqqueue &q){
17 return q.rear==q.front;
18 }
19 int enSeqqueue(Seqqueue &q,Elemtype e){
20 //先判断是否队满
21 if ((q.rear+1)%MAXSIZE==q.front){
22 printf ("full!\n");
23 return 0;
24 }
25 q.rear=(q.rear+1)%MAXSIZE;
26 q.data[q.rear]=e;
27 return 1;
28 }
29 int deSeqqueue(Seqqueue &q,Elemtype &e){
30 if (emptySeqqueue(q)){
31 printf ("null!\n");
32 return 0;
33 }
34 q.front=(q.front+1)%MAXSIZE;
35 e=q.data[q.front];
36 return 1;
37 }
38 Elemtype getFront(Seqqueue &q){
39 if (emptySeqqueue(q)){
40 printf ("null!\n");
41 }
42 else {
43 Elemtype e;
44 q.front=(q.front+1)%MAXSIZE;
45 e=q.data[q.front];
46 return e;
47 }
48 }
49 void display(Seqqueue &q){
50 if (emptySeqqueue(q)){
51 printf ("null!\n");
52 }
53 else {
54 int i=(1+q.front)%MAXSIZE;
55 while (i<=q.rear){
56 printf ("%d ",q.data[i]);
57 i=(i+1)%MAXSIZE;
58 }
59 printf ("\n");
60 }
61 }
62 int getlength(Seqqueue &q){
63 return (q.rear-q.front+MAXSIZE)%MAXSIZE;
64 }
65 int main()
66 {
67 Seqqueue s;
68 initSeqqueue(s);
69 int x;
70 scanf ("%d",&x);
71 while (x!=-999){
72 enSeqqueue(s,x);
73 scanf ("%d",&x);
74 }
75
76 deSeqqueue(s,x);
77 printf ("%d ",x);
78 deSeqqueue(s,x);
79 printf ("%d ",x);
80 scanf ("%d",&x);
81 enSeqqueue(s,x);
82 deSeqqueue(s,x);
83 printf ("%d ",x);
84 cout<<endl;
85 return 0;
86 }表达式求值
1 #include <iostream>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #define MAXSIZE 100
5 using namespace std;
6 typedef char Elemtype;
7 typedef struct {
8 Elemtype elem[MAXSIZE];
9 int top;
10 }SqStack;
11 void initSqstack(SqStack &s){
12 s.top=-1;
13 }
14 int isempty(SqStack &s){
15
16 return s.top==-1;
17 }
18 int push(SqStack &s,Elemtype e){
19 if (s.top>=MAXSIZE-1)
20 return 0;
21 else {
22 s.top++;
23 s.elem[s.top]=e;
24 return 1;
25 }
26 }
27 int pop(SqStack &s,Elemtype &e){
28 if (s.top==-1)
29 return 0;
30 else {
31 e=s.elem[s.top];
32 s.top--;
33 return 1;
34 }
35 }
36 Elemtype gettop(SqStack &s){
37 Elemtype e;
38 e=s.elem[s.top];
39 return e;
40 }
41 int in(Elemtype &c){
42 if (c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#'||c=='\n')
43 return 1;
44 else return 0;
45 }
46 char precede(Elemtype a,Elemtype b){
47 //比较两个运算符的优先级
48 if((a=='+'&&(b=='+'||b=='-'||b==')'||b=='#'))||(a=='-'&&(b=='+'||b=='-'||b==')'||b=='#'))
49 ||(a=='*'&&(b=='+'||b=='-'||b=='*'||b=='/'||b==')'||b=='#'))||(a=='/'&&(b=='+'||b=='-'
50 ||b=='*'||b=='/'||b==')'||b=='#'))||(a==')'&&(b=='+'||b=='-'
51 ||b=='*'||b=='/'||b==')'||b=='#')))
52 return '>';
53 if ((a=='+'&&(b=='*'||b=='/'||b=='('))||(a=='-'&&(b=='*'||b=='/'||b=='('))
54 ||(a=='*'&&b=='(')||(a=='/'&&b=='(')||(a=='('&&(b=='+'||b=='-'
55 ||b=='*'||b=='/'||b=='('))||(a=='#'&&(b=='+'||b=='-'
56 ||b=='*'||b=='/'||b=='(')))
57 return '<';
58 if((a=='('&&b==')')||(a=='#'&&b=='#'))
59 return '=';
60 }
61 Elemtype operate(Elemtype &a,Elemtype &th,Elemtype &b){
62 int aa=a-'0';
63 int bb=b-'0';
64 char c;
65 switch (th){
66 case '+':c=char(aa+bb+'0');
67 break;
68 case '-':c=char(bb-aa+'0');
69 break;
70 case '*':c=char(aa*bb+'0');
71 break;
72 case '/':c=char(aa/bb+'0');
73 break;
74 }
75 return c;
76 }
77 Elemtype evaluateExpression(){
78 SqStack optr,opnd;
79 initSqstack(optr);initSqstack(opnd);
80 push(optr,'#');
81 char c=getchar(),x,theta,a,b;
82 while (c!='#'||gettop(optr)!='#')
83 {
84 //输入#时表达式结束，操作符栈的栈顶元素为#时说明全部弹出并进行运算
85 //如果C是运算符则1, 比较栈顶元素的优先级大小，选择弹栈或者压栈
86 //如果C是数字，这里假定全部为十位数以内，则压栈。
87 //为什么这里是\\，我们想要设置为：两者都为#时循环结束，取非即为a!=#||b!#
88 if (!in(c))
89 {
90 push(opnd,c);c=getchar();
91 }else {
92 switch (precede(gettop(optr),c)){
93 case '>':
94 pop(optr,theta);
95 pop(opnd,a);
96 pop(opnd,b);
97 push(opnd,operate(a,theta,b));
98 //这里不用c=getchar()因为c此时仍然为优先级较小的运算符，应当将循环继续，与gettop的运算
99 //符相比，如果还是比top的运算符小，c还是不能进栈，直到满足＜的条件时才能进栈。
100 break;
101 case '=':pop(optr,x);c=getchar();
102 break;
103 case '<':push(optr,c);c=getchar();
104 break;
105 }
106 }
107 }
108 return gettop(opnd);
109 }
110 int main()
111 {
112 Elemtype c=evaluateExpression();
113 cout<<c;
114
115 return 0;
116 }这种做法的弊端是：只能运算十以内的数字，而且在运算过程中也不能产生大于等于十的结果。
转载于:https://www.cnblogs.com/twomeng/p/9476558.html
严蔚敏版《数据结构 （C语言版）》和《数据结构题集》（五）——栈和队列...相关推荐
- c语言实现bf算法的定位函数,数据结构c语言版严蔚敏清华大学出版社第四章串.ppt...
数据结构c语言版严蔚敏清华大学出版社第四章串 模式匹配(定位) 设有主串S和子串T(将S称为目标串,将T称为模式串),在主串S中,从位置start开始查找,如若在主串S中找到一个与子串T相等的子串,则 ...
- 数据结构c语言版第四章题库,严蔚敏《数据结构(c语言版)习题集》答案第四章 串...
严蔚敏<数据结构(c语言版)习题集>答案第四章 串 第四章 串 4.10 void String_Reverse(Stringtype s,Stringtype &r)//求s的逆 ...
- 数据结构(C语言版)严蔚敏(字符串的模式匹配算法--KMP算法)
数据结构(C语言版)严蔚敏(字符串的模式匹配算法–KMP算法) 1.暴力匹配算法 // 暴力匹配算法 int Index2(SString S,SString T) {// S是主串,T是子串int ...
- 数据结构(C语言版)严蔚敏(树、二叉树的相关概念笔记)
数据结构(C语言版)严蔚敏(树的相关概念笔记) 1. 树中一个节点的孩子个数称为该节点的度,树中节点的最大度数称为树的度: 2. 度大于0的节点称为[分支节点](非终端节点),度为0的节点称为[叶子节 ...
- 严蔚敏数据结构C语言版——线性表的链式存储方式详细代码
一.严蔚敏数据结构C语言版 由于书上的许多地方都是伪代码,所以下面的代码对课本上的做了一些改动,使代码能够正常运行 链表的定义即相关类型定义 typedef int ElementType; type ...
- 数据结构c语言程序题,严蔚敏《数据结构(c语言版)习题集》（包括基础部分）.doc...
严蔚敏<数据结构(c语言版)习题集>(包括基础部分).doc 线性表第1章绪论11简述下列术语数据,数据元素.数据对象.数据结构.存储结构.数据类型和抽象数据类型.解数据是对客观事物的符号 ...
- 数据结构(C语言版)严蔚敏---图的操作的相关代码
1. 将邻接表转换成邻接矩阵 main.cpp void Convert(ALGraph G,MGraph &M){M.vexnum = G.vexnum;M.arcnum = G.arcnu ...
- c语言第二版课后答案pdf,数据结构(C语言版)第2版习题答案—严蔚敏.pdf
数据结构( C语言版) (第2版) 课后习题答案 李冬梅 2015.3 目 录 第 1 章 绪论 1 第 2 章 线性表 5 第 3 章 栈和队列 14 第 4 章 串.数组和广义表 27 第 5 章 ...
- 数据结构c语言版第16页,数据结构c语言版
数据结构c语言版[编辑] 概述 <数据结构C语言版>本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用;后半部分主要讨论查找和排序的各种实现方法及综合分析比较 出版信息 ...
- 数据结构c语言版胡学刚答案,哈夫曼树的建立与实现（最终版）最新版
<哈夫曼树的建立与实现.doc>由会员分享,可免费在线阅读全文,更多与<哈夫曼树的建立与实现(最终版)>相关文档资源请在帮帮文库(www.woc88.com)数亿文档库存里搜索 ...
最新文章
- R语言使用persp函数绘制三维图像实战（3D）：自定义3D图、图像旋转、添加轴标签
- struts2 action间跳转传值
- 转：ECharts图表组件之简单关系图：如何轻松实现另类站点地图且扩展节点属性实现点击节点页面跳转...
- 网站搭建从零开始（六） WordPress的基本配置
- 像亲和数一样亲密无间（洛谷P1851题解，Java语言描述）
- html5自动填充父类框,html5和css3进阶（浮动）----02
- 【HDU5482】Numquam vincar，暴力（da biao）预处理+组合数
- python document_python-docx 常用方法
- Spark.reducer.maxSizeInFlight 参数
- JDK1.8帮助文档chm格式中英文
- intouch写数据到MySQL_如何将intouch数据插入到SQL数据库
- 2016最新淘宝客申请高佣金以及分析抓包详情
- Python global 全局变量，多文件，跨文件使用
- 修改数据库字符集为'us7ascii'
- 这个是没事的时候做出来看的一系列算数表
- 美丽的余霞风景mac高清动态壁纸
- 跨境卖家：如何让海外KOL营销达到理想效果?
- 【蓝桥杯】《试题 基础练习 特殊回文数》详解
- 毕业论文参考文献引用
- l2高斯分布_L1正则先验是Laplace分布，L2正则先验分布是高斯分布
热门文章
- FFmpeg源代码简单分析：configure
- jQuery 文本编辑器插件 HtmlBox 使用
- python定时启动代码_python每天定时运行某程序代码
- java适合年龄_Java实现三人年龄
- 使用阿里云镜像仓库构建国外 Docker 镜像
- java 内嵌机制_[转] Java中public，private，final，static等概念的解读
- TLS certificate verification has been disabled
- 远程使用plsql登陆数据库时，界面提示 ORA-12170 TNS 连接超时
- cycleGAN有matlab代码吗,CycleGAN的代码组成
- 2018年计算机考试玉林地点,广西壮族自治区玉林市2021上半年计算机等级考试时间...