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

#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);
    
    
}