首页 > 编程语言> 文章详细

C语言- 基础数据结构和算法 - 09 栈的应用_中缀表达式转后缀表达式20220611

2022-06-11 21:36:06 阅读：177 来源： 互联网

标签：LinkStack return 中缀 void 09 NULL LinkNode stack 表达式

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

C语言- 基础数据结构和算法 - 09 栈的应用_中缀表达式转后缀表达式20220611

09 栈的应用_中缀表达式转后缀表达式20220611_main.c

LinkStack.c

LinkStack.h