C语言- 基础数据结构和算法 - 09 栈的应用_中缀表达式转后缀表达式20220611
作者：互联网
09 栈的应用_中缀表达式转后缀表达式20220611
听黑马程序员教程《基础数据结构和算法 (C版本)》，
照着老师所讲抄的，
视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1
喜欢的朋友可以去看看，欢迎大家一起交流学习。
09 栈的应用_中缀表达式转后缀表达式20220611_main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkStack.c"
typedef struct MYCHAR{
LinkNode* node;
char* pAddres; // 放字符地址，因为每个字符都有一个地址。
int index; // 记录位置
}MyChar;
// 判断是否是数字
int IsNumber(char c){
return c >='0' && c <='9';
}
// 输出数字
void NumberOperate(char* p){
printf("%c",*p);
}
// 判断是否左括号和右括号
int IsLeft(char c){
return c == '(';
}
int IsRight(char c){
return c == ')';
}
// 判断是否运算符号
int IsOperator(char c){
return c=='+' || c=='-' || c=='*' || c=='/';
}
// 返回运算符的优先级
int GetPriority(char c){
if(c=='*' || c == '/'){
return 2;
}
if(c=='+'|| c=='-'){
return 1;
}
return 0;
}
// 创建MyChar
MyChar* CreateMyChar(char* p){
MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
mychar->pAddres = p;
return mychar;
}
// 左括号进栈
void LeftOperate(LinkStack* stack,char* p){
Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
}
// 右括号操作 弹出并输出，直到匹配左括号
void RightOperate(LinkStack* stack){
// 先判断栈中有没有元素，有则弹，
while(Size_LinkStack(stack)>0){
MyChar* mychar = (MyChar*)Top_LinkStack(stack);
// 如果匹配左括号，则出栈
if(IsLeft(*(mychar->pAddres))){
Pop_LinkStack(stack);
break;
}
// 不匹配左括号，则输出,弹出
printf("%c",*(mychar->pAddres));
Pop_LinkStack(stack);
free(mychar);
}
}
// 运算符号的操作
void OperatorOperator(LinkStack* stack,char* p){
// 先取出栈顶符号
MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
if(mychar==NULL){
Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
return;
}
// 如果栈顶优先级低于当前字符的优先级，则直接入栈
if(GetPriority(*(mychar->pAddres))< GetPriority(*p)){
Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
return;
}
// 如果优先级不低，
else{
while(Size_LinkStack(stack) > 0){
MyChar* mychar2 = (MyChar*)malloc(sizeof(MyChar));
// 如果优先级低，当前符号入栈
if(GetPriority(*(mychar2->pAddres))<GetPriority(*p)){
Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
break;
}
// 输出
printf("%c",*(mychar2->pAddres));
// 弹出
Pop_LinkStack(stack);
// 释放
free(mychar2);
}
}
}
int main(){
printf("好好学习，天天向上~!\t\t\t 09_栈的应用_中缀表达式转后缀表达式20220611\n\n\n");
char* str ="8+(3-1)*5";
char* p = str;
// 创建栈
LinkStack* stack = Init_LinkStack();
while(*p !='\0'){
// 如果是数字，直接输出
if(IsNumber(*p)){
// 直接输出
NumberOperate(p);
}
// 如果是左括号，进栈
if(IsLeft(*p)){
LeftOperate(stack,p);
}
// 如果是右括号，则将栈顶符号弹出并输出，直到匹配左括号
if(IsRight(*p)){
RightOperate(stack);
}
// 如果是运算符号
if(IsOperator(*p)){
OperatorOperator(stack,p);
}
p++;
}
while(Size_LinkStack(stack)>0){
MyChar* mychar = (MyChar*)Top_LinkStack(stack);
printf("%c",*(mychar->pAddres));
Pop_LinkStack(stack);
free(mychar);
}
// 以上输出结果为 831-5*+
printf("\n\n");
system("pause");
return 0;
}
LinkStack.c
1 #ifndef LINKSTACK_H
2 #define LINKSTACK_H
3
4 #include <stdio.h>
5 #include <stdlib.h>
6
7
8 // 链式栈的节点
9 typedef struct LINKNODE{
10 struct LINKNODE* next;
11 }LinkNode;
12
13 // 链式栈
14
15 typedef struct LINKSTACK{
16 LinkNode HeadNode; //头节点
17 int size;
18 }LinkStack;
19
20 // 初始化
21 LinkStack* Init_LinkStack();
22 // 入栈
23 void Push_LinkStack(LinkStack* stack,LinkNode* data);
24 // 出栈 (删除第一个元素）
25 void Pop_LinkStack(LinkStack* stack);
26 // 返回栈顶元素
27 LinkNode* Top_LinkStack(LinkStack* stack);
28 // 返回栈元素的个数
29 int Size_LinkStack(LinkStack* stack);
30 // 清空栈
31 void Clear_LinkStack(LinkStack* stack);
32 // 销毁栈
33 void FreeSpace_LinkStack(LinkStack* stack);
34
35
36
37 #endif
LinkStack.h
1 #include "LinkStack.h"
2
3
4 // 初始化
5 LinkStack* Init_LinkStack(){
6
7 // 开内存
8 LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
9 // 初始化
10 stack->HeadNode.next = NULL;
11 stack->size = 0;
12
13 return stack;
14 }
15
16 // 入栈
17 void Push_LinkStack(LinkStack* stack,LinkNode* data){
18
19 if(stack == NULL){
20 return;
21 }
22 if(data == NULL){
23 return;
24 }
25
26 data->next = stack->HeadNode.next;
27 stack->HeadNode.next = data;
28
29 stack->size++;
30
31 }
32
33 // 出栈 (删除第一个元素）
34 void Pop_LinkStack(LinkStack* stack){
35
36 if(stack == NULL){
37 return ;
38 }
39 if(stack->size==0){
40 return ;
41 }
42
43 // 第一个有效节点
44 LinkNode* pNext = stack->HeadNode.next;
45 stack->HeadNode.next = pNext->next; // pNext.next为第一个有效节点的下一个节点
46
47 stack->size--;
48
49 }
50
51 // 返回栈顶元素
52 LinkNode* Top_LinkStack(LinkStack* stack){
53
54 if(stack == NULL){
55 return NULL;
56 }
57 if(stack->size==0){
58 return NULL;
59 }
60
61 return stack->HeadNode.next;
62 }
63
64 // 返回栈元素的个数
65 int Size_LinkStack(LinkStack* stack){
66 if(stack == NULL){
67 return -1;
68 }
69 return stack->size;
70 }
71
72 // 清空栈
73 void Clear_LinkStack(LinkStack* stack){
74
75 if(stack == NULL){
76 return;
77 }
78 stack->HeadNode.next = NULL;
79 stack->size=0;
80
81 }
82
83 // 销毁栈
84 void FreeSpace_LinkStack(LinkStack* stack){
85
86 if(stack == NULL){
87 return;
88 }
89
90 free(stack);
91
92
93 }
标签：LinkStack,return,中缀,void,09,NULL,LinkNode,stack,表达式 来源： https://www.cnblogs.com/stou/p/16366815.html