数据结构C-6-栈的应用（数制转换、括号匹配、行编辑、简单表达式计算）

fancyZT

于 2020-03-01 21:49:40 发布

阅读量400

点赞数

分类专栏： C

本文链接：https://blog.youkuaiyun.com/fancyZT/article/details/104601188

版权

C 专栏收录该内容

9 篇文章

订阅专栏

1.数制转换

//数制转换
#include<stdio.h>
#include<stdlib.h>
#define MAX_SIZE 100
#define STACKINCREMENT 10
typedef int ElemType;
typedef int Status;
typedef struct Stack{
    ElemType *base;
    ElemType *top;
    int size;
}Stack;
void InitStack(Stack *s);
void Push(Stack *s,ElemType e);
void Pop(Stack *s,ElemType *e);
void Conversion(int n,int d);
int main(void){
    int n,r;
    printf("请输入十进制数:");
    scanf("%d",&n);
     printf("请输入转换的制数:");
     scanf("%d",&r);
     Conversion(n,r);
    return 0;
}
void InitStack(Stack *s){
    s->base=(ElemType*)malloc(sizeof(ElemType));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->size=MAX_SIZE;
}
void Push(Stack *s,ElemType e){
    if(s->top-s->base>=MAX_SIZE){
        s->base=(ElemType*)realloc(s->base,(s->size+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->size;
        s->size+=STACKINCREMENT;
    }
    *s->top++=e;
}
void Pop(Stack *s,ElemType *e){
    if(s->base==s->top)
        exit(-1);
    s->top--;
    *e=*s->top;
}
//将十进制整数n转换为d进制
void Conversion(int n,int d){
    Stack s;
    ElemType e;
    InitStack(&s);
    while(n){
        Push(&s,n%d);
        n/=d;
    }
    while(!(s.top==s.base)){
        Pop(&s,&e);
        printf("%d",e);
    }
    printf("\n");
}

2.括号匹配

//括号匹配
#include<stdio.h>
#include<stdlib.h>
#define MAX_SIZE 100
#define STACKINCREMENT 10
typedef char ElemType;
typedef int Status;
typedef struct Stack{
    ElemType  *base;
    ElemType *top;
    int size;
}Stack;

void InitStack(Stack *s);
int StackEmpty(Stack s);
void Push(Stack *s,char e);
void Pop(Stack *s,char *e);
void GetTop(Stack *s,char *e);
void Match(char *ch);

int main(void){
    char strr[50];
    printf("请输入各种括号\n");
    gets(strr);
    Match(strr);
    return 0;
}
void InitStack(Stack *s){
    s->base=(ElemType*)malloc(sizeof(ElemType));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->size=MAX_SIZE;
}
int StackEmpty(Stack s){
    if(s.base==s.top)
        return 1;
    else return 0;
}
void Push(Stack *s,char e){
    if(s->top-s->base>=MAX_SIZE){
        s->base=(ElemType*)realloc(s->base,(s->size+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->size;
        s->size+=STACKINCREMENT;
    }
    *s->top++=e;
}
void Pop(Stack *s,char *e){
    if(StackEmpty(*s))
        exit(-1);
    s->top--;
    *e=*s->top;
}
//获取栈顶元素
void GetTop(Stack *s,char *e){
    if(StackEmpty(*s))
        exit(-1);
    *e=*(s->top-1);
}
//括号匹配
void Match(char *ch){
    Stack s;
    InitStack(&s);
    char x;
    for(int i=0;ch[i]!='\0';i++){
        if(ch[i]=='('||ch[i]=='['||ch[i]=='{')
            Push(&s,ch[i]);
        if(ch[i]==')'||ch[i]==']'||ch[i]=='}'){
            if(StackEmpty(s)){
                printf("右括号比左括号多\n");return ;
            }

            else{
                    GetTop(&s,&x);
                    if((ch[i]==')'&&x=='(')||(ch[i]==')'&&x=='(') ||(ch[i]==')'&&x=='('))
                        Pop(&s,&x);
                    else{
                        printf("左右括号不同类\n");return;
                    }

            }
        }
    }
    if(StackEmpty(s))
        printf("括号匹配\n");
    else
        printf("左括号比右括号多\n");
}

3.行编辑

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_SIZE 100
#define STACKINCREMENT 10
typedef char ElemType;
typedef int Status;
typedef struct Stack{
    ElemType  *base;
    ElemType *top;
    int size;
}Stack;

void InitStack(Stack *s);
void ClearStack(Stack *s);
void DestroyStack(Stack s);
int StackEmpty(Stack s);
void Push(Stack *s,char e);
void Pop(Stack *s,char *e);
void GetTop(Stack *s,char *e);
void Display(Stack s);

int  main(){
    Stack s;
    InitStack(&s);
    char ch;
    printf("请输入文本(#:退格；@清行):\n");
    ch=getchar();
    while(ch!=EOF){//结束
        while(ch!=EOF&&ch!='\n'){
            switch(ch){
                case '#':Pop(&s,&ch);break;
                case '@':ClearStack(&s);break;
                default:Push(&s,ch);break;
            }
            ch=getchar();
        }
        printf("该行实际文本为:\n");
        Display(s);
        ClearStack(&s);
        if(ch!=EOF)
            ch=getchar();
    }
    printf("\n");
    DestroyStack(s);
    return 0;
}

void InitStack(Stack *s){
    s->base=(ElemType*)malloc(sizeof(ElemType));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->size=MAX_SIZE;
}
void ClearStack(Stack *s){
    s->top=s->base;
}
void DestroyStack(Stack s){
    if(!s.base)
        free(s.base);
    s.base=NULL;
    s.top=NULL;
    s.size=0;
}
int StackEmpty(Stack s){
    if(s.base==s.top)
        return 1;
    else return 0;
}
void Push(Stack *s,char e){
    if(s->top-s->base>=MAX_SIZE){
        s->base=(ElemType*)realloc(s->base,(s->size+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->size;
        s->size+=STACKINCREMENT;
    }
    *s->top++=e;
}
void Pop(Stack *s,char *e){
    if(StackEmpty(*s))
        exit(-1);
    s->top--;
    *e=*s->top;
}
//获取栈顶元素
void GetTop(Stack *s,char *e){
    if(StackEmpty(*s))
        exit(-1);
    *e=*(s->top-1);
}
void Display(Stack s){
    if(StackEmpty(s))
        printf("栈为空\n");
    else{
        ElemType *p;
        p=s.base;
        while(p!=s.top){
            printf("%c",*p);p++;
        }
        printf("\n");
    }
}

4.简单表达式计算

#include<stdio.h>
#include<stdlib.h>
#define MAX_SIZE 100
#define STACKINCREMENT 10

typedef struct {
    char  *base;
    char *top;
    int size;
}SqStack_OPTR;//操作符
typedef struct {
    int  *base;
    int *top;
    int size;
}SqStack_OPND;//操作数
void InitStack_OPND(SqStack_OPND *s);
void InitStack_OPTR(SqStack_OPTR *s);
void Push_OPTR(SqStack_OPTR *s,char e);
void Push_OPND(SqStack_OPND *s,int e);
char Pop_OPTR(SqStack_OPTR *s);
int Pop_OPND(SqStack_OPND *s);
char GetTop_OPTR(SqStack_OPTR *s);
char GetTop_OPND(SqStack_OPND *s);
char get_priority(char a,char b);
int Operate(int a,char theata,int b);
int In(char c);
int EvaluteExpress();
int  main(){
    printf("请输入表达式（以#结尾）：");
    int result=EvaluteExpress();
    printf("表达式结果是：%d",result);
    return 0;
}

void InitStack_OPND(SqStack_OPND *s){
    s->base=(int*)malloc(MAX_SIZE*sizeof(int));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->size=MAX_SIZE;
}
void InitStack_OPTR(SqStack_OPTR *s){
    s->base=(char*)malloc(MAX_SIZE*sizeof(char));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->size=MAX_SIZE;
}
void Push_OPTR(SqStack_OPTR *s,char e){
    if(s->top-s->base>MAX_SIZE){
        s->base=(char*)realloc(s->base,(s->size+STACKINCREMENT)*sizeof(char));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->size;
        s->size+=STACKINCREMENT;
    }
    *s->top++=e;
}
void Push_OPND(SqStack_OPND *s,int e){
    if(s->top-s->base>MAX_SIZE){
        s->base=(int*)realloc(s->base,(s->size+STACKINCREMENT)*sizeof(int));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->size;
        s->size+=STACKINCREMENT;
    }
    *s->top++=e;
}
char Pop_OPTR(SqStack_OPTR *s){
    if(s->top==s->base)
        exit(-1);
    s->top--;
    char e;
    e=*s->top;
    return e;
}
int Pop_OPND(SqStack_OPND *s){
    if(s->top==s->base)
        exit(-1);
    int e;
    s->top--;
    e=*s->top;
    return e;
}
//获取栈顶元素
char GetTop_OPTR(SqStack_OPTR *s){
    if(s->base==s->top)
        exit(-1);
    return *(s->top-1);
}
char GetTop_OPND(SqStack_OPND *s){
    if(s->base==s->top)
        exit(-1);
    return *(s->top-1);
}
//获取优先级
char get_priority(char a,char b){
    char c;
    switch(a){
        case '+':
        case '-':
            if(b=='*'||b=='/'||b=='(') c='<';
            else c='>';
            break;
        case '*':
        case '/':
            if(b=='(') c='<';
            else c='>';
            break;
        case '(':
            if(b=='#'){
                printf("缺少右括号！\n");
                return -1;
               }
            else if(b==')') c='=';
            else c='<';
            break;
        case ')':
            if(b=='('){
                printf("括号不匹配!\n");
                return -1;
               }
            else
                c='>';
            break;
        case '#':
            if(b==')'){
                printf("缺少左括号!\n");
                return -1;
            }
            else if(b=='#')
                c='=';
            else
                c='<';
            break;
    }
    return c;
}
//单项计算
int Operate(int a,char theata,int b){
    switch(theata){
    case '+':
        return a+b;
    case '-':
        return a-b;
    case '*':
        return a*b;
    case '/':
        if(b==0){
            printf("被0除错误\n");
            exit(-1);
        }
        else
            return a/b;
    }
    return 0;
}
//是否进栈
int In(char c){
    switch(c){
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
        case ')':
        case '#':
            return 1;
    }
    return 0;
}
//计算进栈
SqStack_OPND OPND;SqStack_OPTR OPTR;
int EvaluteExpress(){
    InitStack_OPND(&OPND);
    InitStack_OPTR(&OPTR);
    Push_OPTR(&OPTR,'#');
    char c;c=getchar();char x;
    char e;
    int a,b;char theta;
    if( c == '#' && GetTop_OPTR(&OPTR) == '#' ){
        printf( "空表达式。\n" );return -1;
    }
    while( c != '#'||GetTop_OPTR(&OPTR)!='#'){
        if(c>='0'&&c<='9'){
             Push_OPND(&OPND,c-'0');c=getchar();
        }
        else if(c==' '||c=='\t'||c=='\n'){
            c=getchar();continue;
        }
        else if(In(c)){//操作数，进栈
            e=GetTop_OPTR(&OPTR);
             switch(get_priority(e,c)){
                case '<'://栈顶元素优先级低
                    Push_OPTR(&OPTR,c);//进栈
                    c=getchar();
                    break;
                case '=':
                    x=Pop_OPTR(&OPTR);
                    c=getchar();
                    break;
                case '>':
                    theta=Pop_OPTR(&OPTR);
                    a=Pop_OPND(&OPND);
                    b=Pop_OPND(&OPND);
                    Push_OPND(&OPND,Operate(b,theta,a));
                    break;
            }
        }
        else {
            printf("出现非法字符\n");
            return -1;
        }
    }
    return GetTop_OPND(&OPND);
}