C语言- 基础数据结构和算法 - 10 栈的应用_根据后缀表达式求解20220611

10 栈的应用_根据后缀表达式求解20220611

听黑马程序员教程《基础数据结构和算法 (C版本)》，

照着老师所讲抄的，

视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1

喜欢的朋友可以去看看，欢迎大家一起交流学习。

/*
    计算机是如何基于后缀表达式计算的？
    例如：831-5*+
    计算规则：
         遍历后缀表达式中的数字和符号
         对于数字：进栈
         对于符号：
             从栈中弹出右操作数    如在"2+3"中，右操作数为3
            从栈中弹出左操作数    如在，，，， 左，，，，2
            根据符号进行运算
            将运算结果压入栈中
         遍历结束：栈中唯一数字为计算结果
*/   

10 栈的应用_根据后缀表达式求解20220611_main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "LinkStack.c"

/*
    计算机是如何基于后缀表达式计算的？
    例如：831-5*+
    计算规则：
         遍历后缀表达式中的数字和符号
         对于数字：进栈
         对于符号：
             从栈中弹出右操作数    如在"2+3"中，右操作数为3 
            从栈中弹出左操作数    如在，，，， 左，，，，2 
            根据符号进行运算
            将运算结果压入栈中
         遍历结束：栈中唯一数字为计算结果
*/          

typedef struct MYNUM{
    LinkNode node;
    int val;
}MyNum;     

// 判断是否是数字 
int IsNumber(char c){
    return c >='0' && c <='9';
}

// 计算
int Caculate(int left,int right,char c){
    int ret = 0;
    switch(c){
        case '+':
            ret = left+right;
            break;
        case '-':
            ret = left-right;
            break;
        case '*':
            ret = left*right;
            break;
        case '/':
            ret = left/right;
            break;    
        default:
            break;
    }
    
    return ret;
} 


int main(){
    printf("好好学习，天天向上~！\t\t\t  10 栈的应用_后缀式转中缀式20220611\n\n");
    
    // 后缀表达式 
    char* str = "831-5*+"; 
    char* p = str;
    
    LinkStack* stack = Init_LinkStack();
    // 遍历
    while(*p!='\0'){
        // 如果是数字则入栈
        if(IsNumber(*p)){
        
            MyNum* num =(MyNum*)malloc(sizeof(MyNum));
            num->val = *p - '0';        // char转为int 
            Push_LinkStack(stack,(LinkNode*)num);
            printf("num_val=%d\n",num->val);
            //free(num);
            
        }else{    // 不是数字则是运算符
            
            // 先从栈中弹出右操作数（弹出数放在运算符右边）
            MyNum* right = (MyNum*)Top_LinkStack(stack);
            int rightNum = right->val;
            printf("rightNum=%d\n",rightNum);
            Pop_LinkStack(stack);
            free(right);
            
            // 再取左操作数 
            MyNum* left = (MyNum*)Top_LinkStack(stack);
            int leftNum =  left->val;
            printf("leftNum=%d\n",leftNum);
            Pop_LinkStack(stack);
            free(left); 
            
            // 计算
            int ret = Caculate(leftNum,rightNum,*p);
            // 计算结果入栈
            MyNum* num =(MyNum*)malloc(sizeof(MyNum));
            num->val = ret;
            Push_LinkStack(stack,(LinkNode*)num);
                         
        }
                
        p++;
        
    }
    
    if(Size_LinkStack(stack)==1){
        MyNum* num = (MyNum*)Top_LinkStack(stack);
        printf("计算结果为：%d",num->val); 
        Pop_LinkStack(stack);
        free(num);
        
    }
    
    // 释放
    FreeSpace_LinkStack(stack); 
    printf("\n\n");
    system("pause");
    
    return 0;
}

LinkStack.c

#ifndef LINKSTACK_H
#define LINKSTACK_H

#include <stdio.h>
#include <stdlib.h>


// 链式栈的节点 
typedef struct LINKNODE{
    struct LINKNODE* next; 
}LinkNode;

// 链式栈 
 
typedef struct LINKSTACK{
    LinkNode HeadNode;    //头节点
    int size;
}LinkStack; 

// 初始化
LinkStack* Init_LinkStack();
// 入栈
void Push_LinkStack(LinkStack* stack,LinkNode* data);
// 出栈 (删除第一个元素） 
void Pop_LinkStack(LinkStack* stack); 
// 返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack); 
// 返回栈元素的个数
int Size_LinkStack(LinkStack* stack); 
// 清空栈
void Clear_LinkStack(LinkStack* stack);
// 销毁栈
void FreeSpace_LinkStack(LinkStack* stack); 



#endif

LinkStack.h

#include "LinkStack.h"


// 初始化
LinkStack* Init_LinkStack(){
    
    // 开内存
     LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
     // 初始化
     stack->HeadNode.next = NULL;
     stack->size = 0;
    
    return stack;
}

// 入栈
void Push_LinkStack(LinkStack* stack,LinkNode* data){
    
    if(stack == NULL){
        return;
    }
    if(data == NULL){
        return;
    }
    
    data->next = stack->HeadNode.next;
    stack->HeadNode.next = data;
    
    stack->size++;
    
}

// 出栈 (删除第一个元素） 
void Pop_LinkStack(LinkStack* stack){
    
    if(stack == NULL){
        return ;
    }
    if(stack->size==0){
        return ;
    }    
    
    // 第一个有效节点
    LinkNode* pNext =  stack->HeadNode.next;
    stack->HeadNode.next = pNext->next;    // pNext.next为第一个有效节点的下一个节点 
    
    stack->size--;

}

// 返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack){
    
    if(stack == NULL){
        return NULL;
    }
    if(stack->size==0){
        return NULL;
    }            
    
    return stack->HeadNode.next;
}

// 返回栈元素的个数
int Size_LinkStack(LinkStack* stack){
    if(stack == NULL){
        return -1;
    }    
    return stack->size;
}

// 清空栈
void Clear_LinkStack(LinkStack* stack){
    
    if(stack == NULL){
        return;
    }
    stack->HeadNode.next = NULL;
    stack->size=0;    
    
}

// 销毁栈
void FreeSpace_LinkStack(LinkStack* stack){
    
    if(stack == NULL){
        return;
    }
    
    free(stack);
    
    
}