数据结构——栈的应用

任务一

进行栈的模拟将十进制换成八进制输出

代码

#ifndef stack_h
#define stack_h
#include<stdio.h>
#include<stdlib.h>

typedef int T;
struct Stack{
    T*  data;//数据元素存储的开始地址
    int top;//栈顶的位置
    int max;//栈的最大长度
};

Stack* Stack_Create(int maxlen);//创建栈
void Stack_Free(Stack* stk);//释放栈
void Stack_MakeEmpty(Stack* stk);//置为空栈
bool Stack_IsEmpty(Stack* stk);//判空
bool Stack_IsFull(Stack* stk);//判满
T Stack_Top(Stack* stk);//返回栈顶元素
T Stack_Push(Stack* stk, T e);//将元素e压入栈顶，并返回栈顶点元素
T Stack_Pop(Stack* stk);//将栈顶元素弹出，返回栈顶元素
void Stack_Print(Stack* stk);//打印栈顶到栈底元素
void Decimal_Conversion_Octal(T e);//利用栈实现进制转换
#endif

#include<iostream>
#include"hanshu.h"
using namespace std;
int main(){
    T e;
    cin>>e;
    Decimal_Conversion_Octal(e);
    return 0;
}
Stack* Stack_Create(int maxlen){
    Stack* stk = (Stack*)malloc(sizeof(Stack));
    stk->data = (T*)malloc(sizeof(T)*maxlen);
    stk->max = maxlen;
    stk->top = -1;
    return stk;
}
void Stack_Free(Stack* stk){
    free(stk->data);
    free(stk);
}
void Stack_MakeEmpty(Stack* stk){
    stk->top = -1;
}
bool Stack_IsEmpty(Stack* stk){
    return -1==stk->top;
}
bool Stack_IsFull(Stack* stk){
    return stk->top==stk->max-1;
}
T Stack_Top(Stack* stk){
    return stk->data[stk->top];
}
T Stack_Push(Stack* stk, T e){
    if(Stack_IsFull(stk)){
        cout<<"stack is full"<<endl;
        Stack_Free(stk);
        exit(0);//正常运行并退出程序
    }
    else{
        stk->top += 1;
        stk->data[stk->top] = e;
        return Stack_Top(stk);
    }
}
T Stack_Pop(Stack* stk){
    if(Stack_IsEmpty(stk)){
        cout<<"stack is empty"<<endl;
        Stack_Free(stk);
        exit(0);
    }
    else{
        T topE = Stack_Top(stk);
        stk->top -= 1;
        return topE;
    }
}
void Stack_Print(Stack* stk){
    if(Stack_IsEmpty(stk)){
        cout<<"stack is empty"<<endl;
        return ;
    }
    for(int i = stk->top;i >= 0;i--){
        cout<<stk->data[i];
    }
    cout<<endl;
}
void Decimal_Conversion_Octal(T e){
    Stack *L = Stack_Create(110);
    while(e){
        Stack_Push(L,e%8);
        e /= 8;
    }
    Stack_Print(L);
}

exit(0) and exit(1)

$exit(0)$:正常运行程序并退出程序；
$exit(1)$:非正常运行导致退出程序；

任务二

判断字符串括号是否匹配。

思路

我们判断括号匹配利用栈的先进后出和优先级，后放入的左括号的优先级比先放入的左括号优先级更高。

代码

#ifndef stack_h
#define stack_h
#include<stdio.h>
#include<stdlib.h>
typedef int T;
struct Stack{
    T*  data;//数据元素存储的开始地址
    int top;//栈顶的位置
    int max;//栈的最大长度
};

Stack* Stack_Create(int maxlen);//创建栈
void Stack_Free(Stack* stk);//释放栈
void Stack_MakeEmpty(Stack* stk);//置为空栈
bool Stack_IsEmpty(Stack* stk);//判空
bool Stack_IsFull(Stack* stk);//判满
T Stack_Top(Stack* stk);//返回栈顶元素
T Stack_Push(Stack* stk, T e);//将元素e压入栈顶，并返回栈顶点元素
T Stack_Pop(Stack* stk);//将栈顶元素弹出，返回栈顶元素
void Stack_Print(Stack* stk);//打印栈顶到栈底元素
void Bracket_Math(T* str, int len);
//利用stack栈判断括号是否匹配，匹配输出yes，否则输出no
#endif

#include<iostream>
#include"hanshu.h"
using namespace std;
int main(){
    int len;
    T* str;
    cin>>len;
    str = (T*)malloc(sizeof(T)*len);
    cin>>str;
    Bracket_Math(str,len);
    return 0;
}
Stack* Stack_Create(int maxlen){
    Stack* stk = (Stack*)malloc(sizeof(Stack));
    stk->data = (T*)malloc(sizeof(T)*maxlen);
    stk->max = maxlen;
    stk->top = -1;
    return stk;
}
void Stack_Free(Stack* stk){
    free(stk->data);
    free(stk);
}
void Stack_MakeEmpty(Stack* stk){
    stk->top = -1;
}
bool Stack_IsEmpty(Stack* stk){
    return -1==stk->top;
}
bool Stack_IsFull(Stack* stk){
    return stk->top==stk->max-1;
}
T Stack_Top(Stack* stk){
    return stk->data[stk->top];
}
T Stack_Push(Stack* stk, T e){
    if(Stack_IsFull(stk)){
        cout<<"stack is full"<<endl;
        Stack_Free(stk);
        exit(0);//正常运行并退出程序
    }
    else{
        stk->top += 1;
        stk->data[stk->top] = e;
        return Stack_Top(stk);
    }
}
T Stack_Pop(Stack* stk){
    if(Stack_IsEmpty(stk)){
        cout<<"stack is empty"<<endl;
        Stack_Free(stk);
        exit(0);
    }
    else{
        T topE = Stack_Top(stk);
        stk->top -= 1;
        return topE;
    }
}
void Stack_Print(Stack* stk){
    if(Stack_IsEmpty(stk)){
        cout<<"stack is empty"<<endl;
        return ;
    }
    for(int i = stk->top;i >= 0;i--){
        cout<<stk->data[i];
    }
    cout<<endl;
}
void Bracket_Math(T* str, int len){
    bool flag = true;
    int i = 0;
    Stack *ch = Stack_Create(len);
    while(str[i]!='\0'&&flag){
        if(str[i]=='['||str[i]=='('||str[i]=='{'){
            Stack_Push(ch,str[i]);
        }
        else if(str[i]==']'){
            if(!Stack_IsEmpty(ch)&&Stack_Top(ch)=='['){
                Stack_Pop(ch);
            }
            else{
                flag = false;
            }
        }
        else if(str[i]==')'){
            if(!Stack_IsEmpty(ch)&&Stack_Top(ch)=='('){
                Stack_Pop(ch);
            }
            else{
                flag = false;
            }
        }
        else if(str[i]=='}'){
            if(!Stack_IsEmpty(ch)&&Stack_Top(ch)=='{'){
                Stack_Pop(ch);
            }
            else{
                flag = false;
            }
        }
        i++;
    }
    if(flag&&Stack_IsEmpty(ch)){
        cout<<"Yes"<<endl;
    }
    else{
        cout<<"No"<<endl;
    }
}