栈的应用

最新推荐文章于 2022-10-04 15:45:28 发布
最新推荐文章于 2022-10-04 15:45:28 发布
阅读量580 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyxz1314/article/details/40214647
版权

一.数制转换

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define SIZE 100
#define Length 10

int e;
typedef int SElemType;
typedef struct
{
	SElemType *base;
	SElemType *top;
	int size;
}Sqstack;

void InitStack(Sqstack &S)
{
	S.base=(SElemType *)malloc(SIZE*sizeof(SElemType));
	if(!S.base) exit(-1);
	S.top=S.base;
	S.size=SIZE;
}

int StackEmpty(Sqstack S)
{
	if(S.top==S.base) return 1;
	else return 0;
}

void push(Sqstack &S,SElemType e)
{
	if(S.top-S.base>=S.size)
	{
		S.base=(SElemType *)realloc(S.base,(SIZE+Length)*sizeof(SElemType));
		if(!S.base)  exit(-1);
		S.top=S.base+S.size;
		S.size+=Length;
	}
	*S.top++=e;
}

void pop(Sqstack &S)
{
	if(S.top==S.base) exit(-1);
	e=(*--S.top);
}


int main ()
{
	Sqstack S;
	int n,d;
	InitStack(S);
	while(~scanf("%d%d",&n,&d))
	{
		while(n)
		{
			push(S,n%d);
			n=n/d;
		}
		while(!StackEmpty(S))
		{
			pop(S);
			printf("%d",e);
		}
		printf("\n");
	}
	return 0;
}

 

  
#include<cstdio>   
#include<cstring>   
#include<stack>
#include<iostream>    
using namespace std;  
 
int main()  
{  
    stack<int>opnd;  
    int n,d; 
    while(cin>>n>>d)
	{
      while(n)
	  {
		opnd.push(n%d);
	 	n=n/d;
	  }
	  while(!opnd.empty())
	  {
	    cout<<opnd.top();
	    opnd.pop();
	  }
    	cout<<endl;
	}
	return 0;  
}


 

二.表达式求值

  
#include<cstdio>   
#include<cstring>   
#include<stack>
#include<iostream>    
using namespace std;  

int operate(int a,char op,int b)  // 计算
{  
    if(op=='+')  
        return a+b;  
    if(op=='-')  
        return a-b;  
    if(op=='*')  
        return a*b;  
    if(op=='/')  
        return a/b;  
}
  
char precede(char a,char b)    // 比较优先级
{  

	if(a=='+'||a=='-') 
   {
     if(b=='+'||b=='-'||b==')'||b=='#') return '>';
	 if(b=='*'||b=='/'||b=='(') return '<';
   }

   if(a=='*'||a=='/')
   {
     if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#') return '>';
	 if(b=='(') return '<';
   }
	  
	if(a=='(')
	{
	 if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(') return '<';
	 if(b==')') return '=';
	}

	if(a==')')
      if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b==')') return '>';

	if(a=='#')
	 if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b=='(') return '<';

}  

int In(char a)  
{  
    if(a=='+'||a=='-'||a==')'||a=='('||a=='*'||a=='/'||a=='#')  
        return 0;  
    return 1;  
}  

 
int main()  
{  
    stack<int>opnd;  
    stack<char>optr;  
    char c,ans;  
    int num,flag;  
    
    num=flag=0;  
    optr.push('#');  
    c=getchar(); 
	
    while(c!='#'||optr.top()!='#')  
    {  
        if(In(c))  
        {  
            flag=1;  
            num=num*10+c-'0';   // 处理多位数
            c=getchar();  
        }  
        else  
        {  
           if(flag==1)  
           {  
                flag=0;  
                opnd.push(num);   //数字（多位数）入栈
                num=0;  
           }  
           ans=precede(optr.top(),c);  
           if(ans=='<')  
           {  
               optr.push(c);  
               c=getchar();  
		   }
          if(ans=='=')  
          {  
              optr.pop();  
              c=getchar();  
          }  
          if(ans=='>')  
          {  
             int num1,num2;  
             char op; 
			 
             num2=opnd.top();  
             opnd.pop();  

             num1=opnd.top();  
             opnd.pop();  
             
			 op=optr.top();  
             optr.pop();  
             
			 cout<<num1<<' '<<op<<' '<<num2<<endl;   //运算顺序   
             opnd.push(operate(num1,op,num2));  
           }  
        }  
    }  
    cout<<opnd.top()<<endl;  //最终结果      
    return 0;  
}  



#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
#include<iostream>  
using namespace std;  
#define SIZE 100  
#define MAX 10  

char x,a,b;  
typedef char SElemType;  
typedef struct  
{  
	SElemType *base;  
	SElemType *top;  
	int size;  
}Sqstack;  

void InitStack(Sqstack &S)  
{  
	S.base=(SElemType *)malloc(SIZE*sizeof(SElemType));  
	if(!S.base) exit(-1);  
	S.top=S.base;  
	S.size=SIZE;  
}  

char GetTop(Sqstack S)  
{  
	char e;  
	if(S.top==S.base) exit(-1);  
	e=*(S.top-1);  
	return e;  
}  

void push(Sqstack &S,SElemType e)  
{  
	if(S.top-S.base>=S.size)  
	{  
		S.base=(SElemType *)realloc(S.base,(SIZE+MAX)*sizeof(SElemType));  
		if(!S.base)  exit(-1);  
		S.top=S.base+S.size;  
		S.size+=MAX;  
	}  
	*S.top++=e;  
}  

void pop(Sqstack &S,SElemType &e)  
{  
	if(S.top==S.base) exit(-1);  
	e=*--S.top;  
}  


bool in(char a)    
{    
	if(a>='0'&&a<='9')  
		return true;  
	return false;  
}   

char pre(char a,char b)  
{  
	
	if(a=='+'||a=='-')   
	{  
		if(b=='+'||b=='-'||b==')'||b=='#') return '>';  
		if(b=='*'||b=='/'||b=='(') return '<';  
	}  
	if(a=='*'||a=='/')  
	{  
		if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#') return '>';  
		if(b=='(') return '<';  
	}  
	
	if(a=='(')  
	{  
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(') return '<';  
		if(b==')') return '=';  
	}  
	
	if(a==')')  
	{  
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b==')') return '>';  
	}  
	if(a=='#')  
	{  
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b=='(') return '<';  
	}  
}  

int operate(char a,char op,char b)    
{    
	int c,d;  
	c=a-'0';  
	d=b-'0';  
	
	if(op=='+')    
		return c+d;    
	if(op=='-')    
		return c-d;    
	if(op=='*')    
		return c*d;    
	if(op=='/')    
		return c/d;    
}    

int main ()  
{  
	char c;  
	Sqstack optr;  
	Sqstack opnd;  
	InitStack(optr);    
	push(optr,'#');  
	InitStack(opnd);    
	c=getchar();  
	while(c!='#'||GetTop(optr)!='#')  
	{  
		if(in(c))  
		{  
            push(opnd,c);  
            c=getchar(); 
		}  
		else  
		{  
            switch(pre(GetTop(optr),c))  
            {  
				
            case'<': push(optr,c);  
                c=getchar();  
                break;  
            case'=':pop(optr,c);  
                c=getchar();  
                break;  
            case'>':pop(optr,x);  
                pop(opnd,b);  
                pop(opnd,a);  
                push(opnd,operate(a,x,b)+'0');  
        
                break;  
            }  
		}  
	}  
	cout<<GetTop(opnd)-'0'<<endl;  
	return 0;  
}  



#include<stdio.h>    
#include<stdlib.h>    
#include<malloc.h>    
#include<iostream>    
using namespace std;    
#define SIZE 100    
#define MAX 10    

char x;
int a,b; 
 
typedef char SElemType;    
typedef struct    
{    
	SElemType *base;    
	SElemType *top;    
	int size;    
}Sqstack;              // 存字符型

typedef struct    
{    
	int *base;    
	int *top;    
	int size;    
}Sqstack1;            //存整形


void InitStack(Sqstack &S)    
{    
	S.base=(SElemType *)malloc(SIZE*sizeof(SElemType));    
	if(!S.base) exit(-1);    
	S.top=S.base;    
	S.size=SIZE;    
} 
void InitStack1(Sqstack1 &S)    
{    
	S.base=(int *)malloc(SIZE*sizeof(int));    
	if(!S.base) exit(-1);    
	S.top=S.base;    
	S.size=SIZE;    
}                       // 初始化   

char GetTop(Sqstack S)    
{    
	char e;    
	if(S.top==S.base) exit(-1);    
	e=*(S.top-1);    
	return e;    
}    
int GetTop1(Sqstack1 S)    
{    
	int e;    
	if(S.top==S.base) exit(-1);    
	e=*(S.top-1);    
	return e;    
}                       //取栈顶元素

void push(Sqstack &S,SElemType e)    
{    
	if(S.top-S.base>=S.size)    
	{    
		S.base=(SElemType *)realloc(S.base,(SIZE+MAX)*sizeof(SElemType));    
		if(!S.base)  exit(-1);    
		S.top=S.base+S.size;    
		S.size+=MAX;    
	}    
	*S.top++=e;    
}   
void push1(Sqstack1 &S,int e)    
{    
	if(S.top-S.base>=S.size)    
	{    
		S.base=(int *)realloc(S.base,(SIZE+MAX)*sizeof(int));    
		if(!S.base)  exit(-1);    
		S.top=S.base+S.size;    
		S.size+=MAX;    
	}    
	*S.top++=e;    
}                     // 入栈
                      

void pop(Sqstack &S,SElemType &e)    
{    
	if(S.top==S.base) exit(-1);    
	e=*--S.top;    
}    
void pop1(Sqstack1 &S,int &e)    
{    
	if(S.top==S.base) exit(-1);    
	e=*--S.top;    
}                    // 出栈


bool in(char a)      
{      
	if(a>='0'&&a<='9')    
		return true;    
	return false;    
}     

char pre(char a,char b)    
{    
	
	if(a=='+'||a=='-')     
	{    
		if(b=='+'||b=='-'||b==')'||b=='#') return '>';    
		if(b=='*'||b=='/'||b=='(') return '<';    
	}    
	if(a=='*'||a=='/')    
	{    
		if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#') return '>';    
		if(b=='(') return '<';    
	}    
	
	if(a=='(')    
	{    
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(') return '<';    
		if(b==')') return '=';    
	}    
	
	if(a==')')    
	{    
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b==')') return '>';    
	}    
	if(a=='#')    
	{    
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='#'||b=='(') return '<';    
	}    
}    

int operate(int c,char op,int d)      
{      
	 
	if(op=='+')      
		return c+d;      
	if(op=='-')      
		return c-d;      
	if(op=='*')      
		return c*d;      
	if(op=='/')      
		return c/d;      
}      

int main ()    
{    
	int flag,sum;
	char c; 
	
	Sqstack optr;      // 运算符
	Sqstack1 opnd;    // 运算数
	
	InitStack(optr);      
	push(optr,'#');    
	
	InitStack1(opnd);      
	c=getchar();
    flag=sum=0;
	while(c!='#'||GetTop(optr)!='#')    
	{    
		if(in(c))    
		{    
			flag=1;
			sum=sum*10+c-'0';     // 处理多位数 
			c=getchar();   
		}    
		else    
		{    
			if(flag)
			{
			  flag=0;
			  push1(opnd,sum);
			  sum=0;
			}
			switch(pre(GetTop(optr),c))    
			{    
				
			case'<': push(optr,c);    
				c=getchar();    
				break;    
			case'=':pop(optr,c);    
				c=getchar();    
				break;    
			case'>':pop(optr,x);    
				pop1(opnd,b);    
				pop1(opnd,a);    
				push1(opnd,operate(a,x,b));    
				break;    
			}    
		}    
	}    
	cout<<GetTop1(opnd)<<endl;    
	return 0;    
}




 三.括号匹配问题

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<iostream>
using namespace std;

#define S_SIZE 100   //栈的空间大小   
#define STACKINCREAMENT 10//增加空间 


char e;
struct SqStack{  
    char *base; //栈底   
    char *top;  //栈顶   
   int stacksize;   //栈当前的存储空间   
};  


void InitStack(SqStack &S)  
{
	S.base=(char *)malloc(S_SIZE*sizeof(char));  
S.stacksize=S_SIZE;  
S.top=S.base;//初始化空栈   
}  

int StackEmpty(SqStack S)  
{  
    if(S.base==S.top)  
        return 1;  
    else  
        return 0;  
}  

void push(SqStack &S,char e)  
{  
    if(S.top-S.base>=S.stacksize)  
    {
		S.base=(char *)realloc(S.base,(S.stacksize+STACKINCREAMENT)*sizeof(char));  
    S.top=S.base+S.stacksize;  
    S.stacksize+=STACKINCREAMENT;
	}  
    *(S.top)=e;  
    S.top++;        
}  

void pop(SqStack &S,char &e)  
{  
    if(S.base!=S.top)  
    {
		S.top--;  
        e=*S.top;
	}  
}  

int main ()
{
  SqStack s;
  InitStack(s);
  char c[100];
  gets(c);
  int i=0;
  while(i<strlen(c))
  {
    switch(c[i])
	{
	case '(':
	case '[':
	case '{':push(s,c[i++]);break;
    case ')':
	case ']':
	case '}':pop(s,e);
		     if((e=='{' && c[i]=='}') ||(e=='[' && c[i]==']') || (e=='(' &&c[i]==')'))  
				 i++;
             else  
			 {
				 printf("括号匹配不成功\n");
			     exit(-1);
			 }
             break;  
	 default:i++;
	}
  }
 if(StackEmpty(s))  
     printf("括号匹配成功");  
 else  
     printf("括号匹配不成功");  
  printf("\n");  
 return 0;
}


 

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

int main ()
{
  stack<char> s;
  char c[100];
  gets(c);
  int i=0;
   while(i<strlen(c))
   {
    switch(c[i])
	{
	case '(':
	case '[':
	case '{':s.push(c[i++]);break;
    case ')':
	case ']':
	case '}':if((s.top()=='{' && c[i]=='}') ||(s.top()=='[' && c[i]==']') || (s.top()=='(' &&c[i]==')'))  
			 {
				 i++;
			     s.pop();
			 }  
             else  
				 printf("括号匹配不成功\n");
             break;  

	 default:i++;
	}
  }
 
  if(s.empty())  
     printf("括号匹配成功");  
  else  
     printf("括号匹配不成功");  
  printf("\n"); 
 return 0;
}


 

搞么子啊小子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】栈的应用 I ：表达式求值
听雨草堂
09-24 1960
1. 介绍 表达式分为前缀、中缀、后缀。前缀表达式，也称为波兰表达式，其特点是将操作符置于操作数的前面。后缀表达式，也成为逆波兰表达式，所有操作符置于操作数的后面。波兰表达式、逆波兰表达式均是由波兰数学家Jan Łukasiewicz所提出的。中缀表达式将操作符放在操作数中间。前缀表达式和后缀表达式相对于中缀表达式最大的不同是，去掉了表示运算优先级的括号。 1.1 前缀表达
数据结构—栈Stack（数据类型int）
精神小伙
08-03 2393
#pragma once typedef int StackDataType; #include&amp;lt;malloc.h&amp;gt; #include&amp;lt;assert.h&amp;gt; typedef struct Stack { StackDataType* _array; size_t size; size_t capacity; }Stack; void StackIn...
课程笔记 10：数据结构（清华）　栈
icaro_forever的博客
07-25 490
栈是一种特殊的线性序列，元素只能从顶端进入，在从顶端弹出，而对栈的底端则不能进行任何操作。因此，栈是一种具有后进先出特点的数据结构。
java 运算规则_Java 编程处理四则运算式（包含括号）
weixin_33296185的博客
02-16 247
package com.malakana.cal;import android.annotation.SuppressLint;import java.util.*;public class Yunsuan {Yunsuan(String str1) {EvaluateExpression(str1);}@SuppressLint("UseValueOf")public static String...
火星计算器
MWhzx的专栏
08-31 1599
火星计算器
栈及其应用
weixin_51550438的博客
10-04 1797
Java语言介绍栈数据结构
栈和栈的应用
AX_Chu的博客
04-17 2446
一、栈 1、栈的介绍 定义：栈是只允许在一端插入或删除的特定线性表。 栈的应用场景： 1、子程序的调用：在跳往子程序前，会将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2、处理递归调用：和子程序调用类似，除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3、 表达式的转换[中缀表达式转后缀表达式]与求值（实际解决）—使用操作数栈和运算符栈来完成 4、二叉树的遍历—行遍历 5、图形的深度优先（depth—first）搜索法。 2、使用数组来模拟栈 思路分析：
栈_栈应用_
10-04
文档"栈应用.docx"可能进一步详细介绍了这种模拟方法，包括如何处理多个车辆同时进入、如何记录和管理车辆信息，以及如何优化栈的性能，比如动态调整栈的大小等。 总的来说，栈在解决实际问题，如停车场模拟时，能...
Lnodebuhui_栈应用_
10-04
在这个特定的场景中，我们关注的是栈在计算算术表达式中的应用，特别是中缀表达式的求值。本文将深入探讨如何使用栈来解决这一问题。 首先，我们要理解什么是中缀表达式。在日常数学运算中，我们通常使用的运算符...
图文讲解单片机TCP IP协议栈应用
08-13
"图文讲解单片机TCP IP协议栈应用" 本文将详细讲解单片机TCP/IP协议栈的应用，包括单片机TCP/IP协议栈的特点、程序存储空间和外部RAM空间的限制、单片机体系结构的限制，以及现有的单片机TCP IP协议栈解决方案。 ...
基于Spring Framework的Java全功能栈应用程序框架设计源码
05-28
Spring Framework是一个开源的Java/Java EE全功能栈应用程序框架，以Apache许可证形式发布，并支持.NET平台上的移植版本，为开发者提供了一个强大的工具集和灵活的架构设计，适用于构建企业级应用程序。
数据结构-链式栈应用实例-C语言实现判定字符串括号是否配对-数据结构学习
05-27
链式栈的应用实例：可以实现判定字符串中的括号是否配对，如果不配对，可以指出不配对的括号。 压缩包包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 本实例用于C语言以及...
物联网工程_基于RFID的食堂食品安全监测系统设计.docx
07-20
物联网工程_基于RFID的食堂食品安全监测系统设计
VisualSVN-VS2022
最新发布
07-20
VisualSVN-VS2022-8.0.5.vsix SVNVS插件，使用VS自带更新速度太慢，可下载后直接安装即可
基于PSO优化的BP神经网络训练与测试matlab仿真，包括程序，注释，参考文献，操作步骤
07-20
1.版本：matlab2022A。 2.包含：程序，中文注释，参考文献，仿真操作步骤（使用windows media player播放）。 3.领域：PSO优化的BP神经网络 4.仿真效果：仿真效果可以参考博客同名文章《基于PSO优化的BP神经网络训练与测试matlab仿真》 5.内容：基于PSO优化的BP神经网络训练与测试matlab仿真。粒子群优化（Particle Swarm Optimization, PSO）结合BP（Backpropagation）神经网络是一种常见的优化方法，用于提升神经网络的学习能力和泛化能力。PSO不仅帮助BP神经网络找到了一个较好的初始解，从而可能加快了训练过程并提高了最终模型的质量，而且还能探索到更广泛的解空间，有助于避免局部最优解。 6.注意事项：注意MATLAB左侧当前文件夹路径，必须是程序所在文件夹位置，具体可以参考视频录。
超详细讲C++cout语句
07-20
超详细讲C++cout语句，专门为C++初学者录制。
java基于ssm+jsp网络安全宣传网站系统源码 带毕业论文
07-20
【资源说明】 1、开发环境：ssm框架；内含Mysql数据库；JSP技术 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 4、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
java基于ssm+jsp奶茶店管理系统源码 带毕业论文
07-20
【资源说明】 1、开发环境：ssm框架；内含Mysql数据库；JSP技术 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 4、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
lin协议栈应用分享
09-12
以下是关于LIN协议栈应用的一些分享。 首先，LIN协议栈在车辆电子系统中常用于连接各种低速率从设备，如门控制单元、窗户控制单元、座椅控制单元等。通过LIN总线，这些从设备可以与车辆主控制单元进行通信和控制。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值