利用栈实现的经典案例

最新推荐文章于 2022-10-07 22:43:23 发布
最新推荐文章于 2022-10-07 22:43:23 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： c语言 文章标签： 数据 typedef struct ifndef
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mahao1107/article/details/47220277
版权
本文介绍了如何利用栈来实现三个经典案例：任意进制转换、中缀表达式转后缀表达式并进行计算，以及括号符号的匹配。通过linklist和linkstack的数据结构，实现了相关功能，强调思路的重要性。
摘要由CSDN通过智能技术生成

1.用栈来实现任意进制进制转换

//linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef struct linklistnode         
{
    struct linklistnode *next;      
    int item;
}LinkListNode;             //数据节点 

typedef struct linklist         
{
    LinkListNode header;        
    int length;

}LinkList;               //头节点   

LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list,int pos);
LinkListNode *LinkList_Delete(LinkList *list,int pos);

#endif  //__LINKLIST_H__

//linklist.c

#include <stdlib.h>

#include "linklist.h"


LinkList *LinkList_Create()
{
    LinkList *ret = NULL;

    ret = malloc(sizeof(LinkList));

    if(ret!=NULL)
    {
        ret->length = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList *list)
{
    free(list);
}

void LinkList_Clear(LinkList *list)
{
    if(list!=NULL)
    {
        list->length =0;
        list->header.next = NULL;
    }
}

int LinkList_Length(LinkList *list)
{
    int ret = -1;

    if( list!=NULL )
    {
        ret = list->length; 
    }

    return ret;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
    int ret = list!=NULL && node!=NULL && pos>=0;

    if( ret )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0;i<pos && cur->next!=NULL;i++)
        {
            cur = cur->next; 
        }
        node->next = cur->next;
        cur->next = node;
        list->length++;
    }

    return ret;
}

LinkListNode *LinkList_Get(LinkList *list,int pos)
{
    LinkListNode *ret = NULL;

    if( list!=NULL && (0<=pos && pos<list->length) )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;        //因为从0开始计数的，要第三个数，那么就是第二个数的next
    }

    return ret;
}

LinkListNode *LinkList_Delete(LinkList *list,int pos)
{
    LinkListNode *ret = NULL;

    if(list!=NULL && (0<=pos&&pos<list->length) )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;    //单项链表是从0开始排的。
        cur->next = ret->next;
        list->length--;
    }

    return ret;
}

//linkstack.h

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__


typedef struct linkstacknode
{
    struct linkstacknode *node;
    void *item;
}LinkStackNode;

typedef void LinkStack;

LinkStack *LinkStack_Create();
void LinkStack_Destroy(LinkStack *stack);
void LinkStack_Clear(LinkStack *stack);
int LinkStack_Push(LinkStack *stack,void *item);
void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);
int LinkStack_Size(LinkStack *stack);

#endif //__LINKSTACK_H__

//linkstack.c

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

#include "linklist.h"
#include "linkstack.h"


LinkStack *LinkStack_Create()
{
    return LinkList_Create();
}

void LinkStack_Destroy(LinkStack *stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack *stack)
{
    while ( LinkStack_Size(stack) > 0 )
        LinkStack_Pop(stack);
}


int LinkStack_Push(LinkStack *stack,void *item)
{
    LinkStackNode *node = malloc(sizeof(LinkStackNode));
    int ret = stack!=NULL && item!=NULL && node!=NULL;

    if( ret )
    {
        memset(node,0x00,sizeof(*node)); //?? 
        node->item = item;
        ret = LinkList_Insert(stack, (LinkListNode *)node, 0);
    }

    if(!ret)
    {
        free(node);
    }

    return ret;
}

void *LinkStack_Pop(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode *)LinkList_Delete(stack,0);

    if ( node != NULL)
    {
        ret = node->item;
        free(node);
    }

    return ret;
}

void *LinkStack_Top(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode *)LinkList_Get(stack,0);

    if( node!=NULL)
    {
        ret = node->item; 
    }
    return ret;
}
int LinkStack_Size(LinkStack *stack)
{
    return LinkList_Length(stack);
}

//main.c

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

#include "linkstack.h"


void convert(int digit,int base)
{
    static char num[]= {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};

    LinkStack *stack = LinkStack_Create();

    do
    {
        LinkStack_Push(stack,&num[digit%base]); //进栈
        digit /= base;

    }while( digit!= 0 );

    while ( LinkStack_Size(stack) > 0 )
    {
        char *c = (char *)LinkStack_Pop(stack); //出栈
        printf("%c", *c);
    }
    printf("\n");

    LinkStack_Destroy(stack);
}

int main( void )
{
    convert(10,2);  //十进制的10转换为2进制

    convert(32,16);  //十进制的转换为16进制 

    return 0;
}

Makefile


cc :=gcc

main : main.o linklist.o linkstack.o
    gcc $^ -o $@


.PHONY : main clean

clean:
    rm -rf *.o main

2.用栈来实现加、减、乘、除的计算

中缀转后缀

对于数字，直接输出
    对于符号：
        左括号：进栈
        符号：于栈顶符号进行优先级比较
        栈顶优先级低：进栈
        栈顶优先级不低，将栈顶符号弹出并输出，之后进栈
        右括号：将栈顶符号弹出并输出，知道匹配左括号

    遍历结束：将栈中所有符号弹出并输出

后缀表达式计算：

对于数字：进栈
对于符号：
    从栈中弹出右右操作数
    从栈中弹出左操作数
    根据运算符进行运算
    将运算结果入栈
遍历结束：栈中唯一数字就是运算结果

有时候代码不重用，重要的是我们的思路，当我们有思路，那么我们剩下的就是把我们向的变为代码就ok了

//linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef struct linklistnode         
{
    struct linklistnode *next;      
    int item;
}LinkListNode;             //数据节点 

typedef struct linklist         
{
    LinkListNode header;        
    int length;

}LinkList;               //头节点   

LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list,int pos);
LinkListNode *LinkList_Delete(LinkList *list,int pos);

#endif  //__LINKLIST_H__

//linklist.c

#include <stdlib.h>

#include "linklist.h"


LinkList *LinkList_Create()
{
    LinkList *ret = NULL;

    ret = malloc(sizeof(LinkList));

    if(ret!=NULL)
    {
        ret->length = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList *list)
{
    free(list);
}

void LinkList_Clear(LinkList *list)
{
    if(list!=NULL)
    {
        list->length =0;
        list->header.next = NULL;
    }
}

int LinkList_Length(LinkList *list)
{
    int ret = -1;

    if( list!=NULL )
    {
        ret = list->length; 
    }

    return ret;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
    int ret = list!=NULL && node!=NULL && pos>=0;

    if( ret )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0;i<pos && cur->next!=NULL;i++)
        {
            cur = cur->next; 
        }
        node->next = cur->next;
        cur->next = node;
        list->length++;
    }

    return ret;
}

LinkListNode *LinkList_Get(LinkList *list,int pos)
{
    LinkListNode *ret = NULL;

    if( list!=NULL && (0<=pos && pos<list->length) )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;        //因为从0开始计数的，要第三个数，那么就是第二个数的next
    }

    return ret;
}

LinkListNode *LinkList_Delete(LinkList *list,int pos)
{
    LinkListNode *ret = NULL;

    if(list!=NULL && (0<=pos&&pos<list->length) )
    {
        int i;
        LinkListNode *cur = (LinkListNode *)list;

        for(i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;    //单项链表是从0开始排的。
        cur->next = ret->next;
        list->length--;
    }

    return ret;
}

//linkstack.h

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__


typedef struct linkstacknode
{
    struct linkstacknode *node;
    void *item;
}LinkStackNode;

typedef void LinkStack;

LinkStack *LinkStack_Create();
void LinkStack_Destroy(LinkStack *stack);
void LinkStack_Clear(LinkStack *stack);
int LinkStack_Push(LinkStack *stack,void *item);
void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);
int LinkStack_Size(LinkStack *stack);


#endif //__LINKSTACK_H__

//linkstack.c

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

#include "linklist.h"
#include "linkstack.h"


LinkStack *LinkStack_Create()
{
    return LinkList_Create();
}

void LinkStack_Destroy(LinkStack *stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack *stack)
{
    while ( LinkStack_Size(stack) > 0 )
        LinkStack_Pop(stack);
}


int LinkStack_Push(LinkStack *stack,void *item)
{
    LinkStackNode *node = malloc(sizeof(LinkStackNode));
    int ret = stack!=NULL && item!=NULL && node!=NULL;

    if( ret )
    {
        memset(node,0x00,sizeof(*node)); //?? 
        node->item = item;
        ret = LinkList_Insert(stack, (LinkListNode *)node, 0);
    }

    if(!ret)
    {
        free(node);
    }

    return ret;
}

void *LinkStack_Pop(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode *)LinkList_Delete(stack,0);

    if ( node != NULL)
    {
        ret = node->item;
        free(node);
    }

    return ret;
}

void *LinkStack_Top(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode *)LinkList_Get(stack,0);

    if( node!=NULL)
    {
        ret = node->item; 
    }
    return ret;
}
int LinkStack_Size(LinkStack *stack)
{
    return LinkList_Length(stack);
}

//main.c

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

#include "linkstack.h"

int isNum(char c)
{
    return c>='0' && c<='9';
}

int isLeft(char c)
{
    return c=='(';
}

int isRight(char c)
{
    return c==')';
}

int isOperator(char c)
{
    return c=='+' || c=='-' || c=='*' || c=='/';
}

int priority(char c)
{
    int ret=0;

    if( c=='+' || c=='-' )
        ret = 1;
    if( c=='*' || c=='/' )
        ret = 2;

    return ret;
}

//前缀表达式：
void transfrom( const char *exp, char *buf)
{
    int i = 0;
    int idx = 0;
    LinkStackNode *stack = LinkStack_Create();

    while ( exp[i] != 0 )
    {
        if( isNum(exp[i]))     //是数字，直接输出
        {
            //putchar(exp[i]);
            buf[idx++] = exp[i]; 
        }
        else if( isLeft(exp[i]) )   //是左（就进栈
        {
            LinkStack_Push(stack, ( void * )(int)exp[i]); 
        }
        else if ( isOperator(exp[i]) )  //是运算符,就进行比较优先级
        {
            while(priority(exp[i]) <= priority((char)(int)LinkStack_Top(stack))) 
            {
                //putchar((char)(int)LinkStack_Pop(stack)); //输出栈顶元素
                buf[idx++] = ((char)(int)LinkStack_Pop(stack));
            }
            LinkStack_Push(stack, (void *)(int)exp[i]); //在把它进栈
        }
        else if( isRight(exp[i]) )  //是右） 并且栈顶的不是（,就让他一直输出栈顶元素
        {
            while ( !isLeft( (char)(int)LinkStack_Top(stack) )) 
            {
                //putchar((char)(int)LinkStack_Pop(stack)); 
                buf[idx++] = ((char)(int)LinkStack_Pop(stack)); 
            }
            LinkStack_Pop(stack);   //栈顶是（,则弹出并没有输出
        }
        else
        {
            printf("invalid expresstiom!\n"); 
            break;
        }

        i++;
    }

    while(exp[i]==0 && LinkStack_Size(stack) )  //没有了表达式，并且栈有操作符，就让他直接输入
    {
        //putchar((char)(int)LinkStack_Pop(stack)); 
        buf[idx++] = ((char)(int)LinkStack_Pop(stack)); 
    }
    //putchar('\n');
    buf[idx] = 0;       //加了一个‘\0'

    LinkStack_Destroy(stack);
}


int value(char c)
{
    return c-'0';
}


int operation(int left,int right, int op)
{
    int ret = 0;

    switch (op)
    {
        case '+':
            ret = left + right;
            break;
        case '-':
            ret = left - right;
            break;
        case '*':
            ret = left * right;
            break;
        case '/':
            assert(right);
            ret = left / right;
            break;
        default:
            printf("error!\n");
            exit(1);
            break;
    }

    return ret;
}


//后缀表达式：
int compute(const char *exp)
{
    int i = 0;
    int res = 0;
    LinkStack *stack = LinkStack_Create();

    while ( exp[i]!= 0 )
    {
        if( isNum(exp[i]) )     //是数字，就进栈
        {
            LinkStack_Push(stack, (void *)value(exp[i])); 
        }
        else if( isOperator(exp[i]) )   //是操作数，就让栈顶两个数出栈，进行运算
        {
            int r = (int)LinkStack_Pop(stack);
            int l = (int)LinkStack_Pop(stack);
            int ret = operation(l,r,exp[i]);
            LinkStack_Push(stack, (void *)ret);
        }
        else
        {
            printf("invalid expression!\n"); 
            break;
        }

        i++;
    }

    if( LinkStack_Size(stack)==1 && exp[i]==0 ) //只有输入一个数的时候，直接让他输出
    {
        res = (int)LinkStack_Pop(stack); 
    }

    LinkStack_Destroy(stack);

    return res;
}


int main( void )
{

    char buf[1024] = {};
    char exp[1024] = {};

//    transfrom("5+3*2");

    while ( 1 )
    {
        printf("输入一个算式表达式:"); 
        fgets(buf, 1024, stdin);    //标准输入放入buf中
        buf[strlen(buf)-1] = 0;     //清掉最后一个换行符
        transfrom(buf, exp);        //表达式通过buf传过去，在通过exp带回来结果，
        printf("%s=", buf);
        printf("%d\n",compute(exp));

    }

//    printf("9-3*2+(5-1)");
//    printf("%d\n",compute("932*-51-+"));
    return 0;
}

//Makefile


cc :=gcc

main : main.o linklist.o linkstack.o
    gcc $^ -o $@


.PHONY : main clean

clean:
    rm -rf *.o main

3.用栈来实现符号的匹配

和上一个的其他函数都一样，就主函数变化为：

//main.c

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

#include "linkstack.h"

int isLeft(char c)
{
    return c == '{' || c == '[' || c == '(' || c == '<';
}

int isRight(char c)
{
    return c == '}' || c == ']' || c == ')' || c == '>';
}

//匹配
int match(char left, char right)
{
    int ret;

    switch (left)
    {
        case '{': 
            ret = right == '}';
            break;
        case '[': 
            ret = right == ']';
            break;
        case '(': 
            ret = right == ')';
            break;
        case '<': 
            ret = right == '>';
            break;
        default:
            ret = 0;
            break;
    }

    return ret;
}

/*
//扫描
int scanner( const char *code )
{
    int i = 0;
 //   int ret = 0;

    LinkStackNode *stack = LinkStack_Create();

    while ( code[i] !='\0' )
    {
        if( isLeft(code[i]) )
        {
            LinkStack_Push(stack, (void *)(int)code[i]); 
        }
        if( isRight(code[i]))
        {
            char c = (char)(int)LinkStack_Pop(stack);
            if( !match(c, code[i]) )
            {
                printf("%c no matched\n",code[i]); 
                return -1;
           //     break;
            }
        }
        i++;
    }

    if( LinkStack_Size(stack)==0 && code[i]=='\0' )
    {
        printf("success!\n"); 
    }
    else
    {
        printf("invalid!\n");
    }

    LinkStack_Destroy(stack);

    return 0;
//    return ret;
}

*/

int scanner( const char *code )
{
    int i = 0;
    int ret = 0;

    LinkStackNode *stack = LinkStack_Create();

    while ( code[i] !='\0' )
    {
        if( isLeft(code[i]) )
        {
            LinkStack_Push(stack, (void *)(int)code[i]); 
        }
        if( isRight(code[i]))
        {
            char c = (char)(int)LinkStack_Pop(stack);
            if( !match(c, code[i]) )
            {
                printf("%c no matched\n",code[i]); 
                ret = -1;
                break;
            }
        }
        i++;
    }

    if( LinkStack_Size(stack)==0 && code[i]=='\0' )
    {
        printf("success!\n"); 
    }
    else
    {
        printf("invalid!\n");
    }

    LinkStack_Destroy(stack);

    return ret;
}


int main( void )
{
    const char *code = "#include <stdlib.h>"
                        "int main( void )"
                            "}";

    scanner(code);

    return 0;
}
Fireworks_light
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆栈队列实例
acmsongye的博客
06-10 6432
堆栈：先进后出 队列：先进先出 日常生活中队列很常见。还有什么堆栈的典型例子？ 夏天逛超市时，你可能会忍不住想喝一瓶冰饮料降降温。 可是，困扰你的是：放冰箱外头的饮料往往并不冰，而冰箱深处你够不着的地方，才是你想要的。 想想看：冰箱中的饮料应该组织成“队列”还是“堆栈”？你对超市中的冰箱设计有什么改进性的建议？ 比如交试卷，假设学生交试卷的方向都统一，且后来的学生都放在
数据结构——栈
weixin_57525369的博客
05-07 4254
栈的概念 栈：是一个种特殊的线性表，只允许在固定的一端进行插入与删除元素的操作。在进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。栈中的元素遵守后进先出的原则。也叫先进后出。 举个例子：栈在我们的生活中的应用是经常见到的。我们大家在小时候应该都会玩过玩具枪，玩具枪里面的弹夹大家都不陌生吧，一颗一颗的子弹压入弹夹中，最后压入的子弹是最先被发射出来的。 在软件应用中，也是非常普遍的。比如我们在用浏览器浏览东西时，不管什么浏览器都会有一个“返回键”，点击后会按照你访问的顺序逆序后退...
【数据结构与算法】栈的介绍与实现（详解）
平淡中造就不平凡
11-20 536
【本节目标】 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶
栈的应用举例
最新发布
qq_57484399的博客
10-07 4244
栈和队列主要用于计算过程中保存的临时数据，如果数据在编程时就可以确定，那么使用几个变量就可以临时存储，但是如果存储的数据项数不能确定，就需要复杂的存储机制。这样的存储机制称为缓存。栈和队列就是使用最多的缓存结构。我们在调用方法的时候 , 时常调用别的成员方法, 递归循环调用 , 那调用到最后,又从最后一个函数,依次返回值 , 我们熟悉这个机制.但是我们却不知道 , 编译器是如何把这些调用信息存储起来的,用什么方法存储起来的, 这里就需要我们用到栈了,先进后出还有生活中 , 我们往木桶里放球 ,
栈的几个实例应用
heitong_fu的博客
08-25 4480
简单括号匹配 问题描述：括号的使用必须遵循 “平衡”规则，即 首先，每个开括号要恰好对应一个闭括号； 其次，每对开闭括号要正确的嵌套 正确的括号：(()()()())，(((())))， (()((())())) 错误的括号：((((((())，()))，(()()(() 对括号是否正确匹配的识别，是很多语言编译器的基础算法 解题思路：从左到右扫描括号串，最新打开的左括号，应该匹配最先遇到的右括号 这样，第一个左括号（最早打开），就应该匹配 最后一个右括号（最后遇到） 这种次序反转的识别，正好符合栈的特性
c语言经典案例
10-30
本文件中讲述了c语言经典的282个案例，由浅入深。有利于提高广大爱好c语言编程的人员。 其中包括： 第1章 初识C语言 1 实例001 第一个C语言程序 2 实例002 一个完整的C语言程序 2 实例003 输出名言 3 实例004 用TC ...
数据结构利用栈实现算术表达式的求值 C语言版
05-08
总的来说，利用栈实现算术表达式的求值是数据结构与算法的经典应用，它展示了如何通过有效的数据结构和逻辑处理复杂问题。在这个过程中，我们不仅练习了对栈的理解，还锻炼了对运算符优先级规则的掌握，以及字符串...
java十大经典案例
05-18
在学习过程中，记得阅读《Java十大经典案例》光盘使用说明书，了解每个案例的详细步骤和光盘内容，以便更好地理解和实现这些项目。同时，不断动手实践，理论与实践相结合，才能真正掌握Java编程。
数据结构经典案例.docx
10-10
在这个经典案例中，我们面临的是一个停车场管理问题，通过这个案例可以深入理解栈这一数据结构的应用。 首先，停车场问题的核心在于车辆的进出管理。管理员需要根据车辆的到达和离开顺序，合理调度车辆，确保停车场...
Java十大经典案例
03-27
Java作为一门广泛使用的编程语言，其经典案例是学习和理解其特性和应用的重要途径。"Java十大经典案例"由张恒汝编著，通过科学出版社发行，旨在为学习者提供丰富的实践素材，深入理解Java的强大功能。以下是这些案例...
简单栈的两道例子
weihuiming
03-22 4633
引言    两道关于栈的简单例子：    1.单词逆序        用栈进行单词逆序：输入一个字符串，然后输出原字符串顺序倒置后的字符串。        首先，字符串从输入的时候一个接一个的提取出来并且压入栈中。接着它们依次弹出栈，并显示出来。因为栈的后进先出的特性，所以字母的顺序就颠倒过来了。/** * @Description Reverse 栈单词逆序--栈 * @author whm...
栈的实例应用
weixin_63816398的博客
05-05 1167
我们把平时所用的标准四则运算表达式，即“9+(3-1)×3+10÷2”叫做中缀表达式。下面我们用栈来实现综合计算器。 使用栈完成表达式的计算思路 通过一个index值来遍历表达式 如果发现是数字直接入栈 如果发现当前符号栈为空，就直接入栈 如果符号栈不为空，就要进行比较。如果当前操作符优先级<=栈中的操作符，就需要从数栈中pop俩个数，符号栈pop一个进行运算，得到的结果入数栈，当前读取到的操作符入符号栈，如果当前优先级大的话，直接入符号栈 当前表达式扫描完毕，就...
栈和队列的简单实例
坚持走下去
06-08 2854
栈 import java.util.Stack; public class StackClass { public static void main(String[] args) { Stack s=new Stack(); s.push("A"); s.push("B"); s.push("C");
栈 使用案例总结
算法channel
03-20 418
最近有几位球友问我，不知道怎么使用单调栈解决实际问题，今天我通过一道leetcode题目，来详细解读如何使用单调栈。1 单调栈单调栈是指栈内元素组织有序的栈，分为单调递增栈和单调递减栈。如...
关于栈及其应用示例
热门推荐
lucasma的博客
06-14 1万+
作为一种常用的数据结构, 了解栈对于算法的学习是非常必要的。栈有先进后出的特点，栈底指向数据表中的第一个元素，栈顶指向最后一个元素的下一个位置。如下图所示: 栈和线性表类似，也是有两种存储结构，分别为顺序结构和链式结构。大部分情况下，栈使用前者，这和它的使用场景有关，因为通常情况下我们不会对栈进行频繁地，随机地插入，删除操作。下面是我用顺序结构实现的栈，这个栈有个特点就是...
栈与堆几个经典的例子
Kyle
01-09 1632
先看看代码呗 public static void main(String args[]) { /* * "==" 对包装类型是进行 的地址比较。i1和i2为引用类型存放在栈区， * new Integer(13) 存放在堆区，并在堆区生成了2份。 * 因此i1和i2指向了堆区不同的地址。 *
04.链栈的简单案例
chongyang_的博客
11-08 844
#include<stdio.h> #include<malloc.h> #include <iostream> using namespace std; #define OK 1 #define ERROR 0 typedef int Status; typedef struct StackNode { Status data; struct StackNode *next; } StackNode, *LinkStack; //初始化栈 St
03.顺序栈的简单案例
chongyang_的博客
11-08 1669
#include<stdio.h> #include<stdlib.h> #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef char ElemType; typedef int Status; //顺序栈的存储结构 typedef struct { ElemType *base; ElemType *top; int stackSize; } sqSta
C语言数据结构-栈的使用及实例
qq_53160758的博客
02-20 3842
C语言数据结构——栈的使用及实例 本文主要讨论C语言数据结构的又一重要结构——栈 栈的理论知识 定义和特点 定义：只允许在一端插入和删除的线性表；允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。 特点：后进先出 (LIFO) 栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 ​使用通俗的话语形容就像压入子弹夹的子弹，先压入
递归实现：二阶费波纳奇数列与算法解析
"二阶费波纳奇数列的栈和递归实现" 二阶费波纳奇数列是一种扩展自经典斐波那契数列的数学概念，它在计算机科学中常用于演示递归算法的实现。经典斐波那契数列定义为F(n) = F(n-1) + F(n-2)，而二阶费波纳奇数列则是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值