数据结构之栈的应用

最新推荐文章于 2023-08-26 10:48:44 发布
最新推荐文章于 2023-08-26 10:48:44 发布
阅读量597 收藏 8
点赞数
分类专栏： 数据结构 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43607916/article/details/108822848
版权

栈的应用

文章目录

  • 括号匹配
  • 表达式
  • 递归
  • 进制转化

1.括号匹配

假设一个算术表达式中包含()、[] 和 {}3种类型的括号，编写一个算法判别表达式中括号是否匹配，以字符‘\0’作为算术表达式的结束符。

算法思想：

扫描每个字符，遇到圆、方、花的左括号是进栈，遇到圆、方、花的右括号时检查栈顶元素是否为相应的左括号，若是，退栈，否则匹配错误。最后栈不为空也为错误。

在这里插入图片描述

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define Maxsize 50
typedef char Datatype;
typedef struct{
Datatype data[Maxsize];
int top;
}SqStack;
void InitStack(SqStack *S)
{
    S->top=-1;
}
int StackEmpty(SqStack *S)
{
    if(S->top==-1)
        return 0;
    else
        return 1;
}
int Push (SqStack *S,Datatype x)
{
    if(S->top==Maxsize-1)
        return 0;
    else
        S->data[++(S->top)]=x;
        return 1;
}
int Pop(SqStack *S, Datatype *x)
{
    if(S->top==-1)
        return 0;
    else
        *x=S->data[(S->top)--];
    return 1;
}
int GetTop(SqStack S,Datatype *x)
{
    if(S.top==-1)
        return 0;
    else
        *x=S.data[S.top];
    return 1;
}
int Bracketscheck(SqStack *S,char *str)
{
     InitStack(S);
     char e;
     int i=0;
     while(str[i]!='\0')
     {
         switch(str[i]){
     case '(':
            Push(S,'(');
            break;
     case '{':
        Push(S,'{');
        break;
     case '[':
        Push(S,'[');
        break;
     case ')':
        Pop(S,&e);
        if(e!='(')
            return 0;
        break;
     case '}':
        Pop(S,&e);
        if(e!='{')
            return 0;
        break;
     case ']':
        Pop(S,&e);
        if(e!='[')
            return 0;
        break;
       default:
        break;

         }
         i++;
     }
     int h=StackEmpty(S);
     if(h==1)
        return 0;
     else
        return 1;
}
int main()
{    SqStack S;
    char str[Maxsize];
    printf("请输入你要收入的字符串：");
    scanf("%s",str);
    int h=Bracketscheck(&S,str);
    if(h==0)
        printf("括号不匹配");
    else
        printf("括号匹配");
    return 0;
}

在这里插入图片描述
在这里插入图片描述

2.表达式

  • 中缀表达式转后缀表达式
  • 后缀表达式的计算
  • 中缀表达式的计算

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

附上代码

//后缀表达式的计算

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<ctype.h>
#define STACK_SIZE    20
#define STACK         10
#define MAXBUFFER     10
typedef double ElemType;
typedef struct
{
	ElemType *base;
	ElemType *top;
	int stack_size;
 } sqstack;
void  initstack(sqstack *s)
 {
 	s->base=(ElemType *)malloc(STACK_SIZE * sizeof(ElemType));
 	if(!s->base)
 	{
 		exit(0);
	 }
	 s->top=s->base;
	 s->stack_size=STACK_SIZE;
 }
 void push(sqstack *s,ElemType e)
 {
 	if(s->top - s->base>=s->stack_size)
 	{
 		s->base=(ElemType *)realloc(s->base,(s->stack_size+STACK) *sizeof(ElemType));
	 }
	if(!s->base)
	{
		exit(0);
	}
	*(s->top)=e;
 	s->top++;
 }
 void pop(sqstack *s,ElemType *e)
 {
 	if(s->top==s->base)
 	{
 		return ;
	 }
	 *e=*--(s->top);
 }
 int stacklen(sqstack s)
 {
 	return(s.top - s.base);
 }
 int main()
 {
 	sqstack s;
 	char c;
 	double d,e;
 	char str[MAXBUFFER];//定义缓冲区 
 	int i;
 	initstack(&s);
 	printf("请按照逆波兰表达式输入待计算数据，数据域运算符之前用空格隔开，以'#'作为结束标志\n");
 	scanf("%c",&c);
	 while (c!='#')
 	{
 		while(isdigit(c) || c=='.')//48-57,0-9
 		{
 			str[i++]=c;
 			str[i]='\0';
			 if(i>=10)
			 {
			 	printf("出错，输入的单个数据过大！\n");
			 	return -1;
			 }
			 scanf("%c",&c);
			 if(c==' ')
			 {
			 	d=atof(str);//将字符串转化为浮点数
				 push(&s,d); 
				 i=0;
				 break;
			 }
		 }
		 switch(c)
 		{
 			case'+':
 				pop(&s,&e);
 				pop(&s,&d);
 				push(&s,d+e);
 				break;
 			case'-':
 				pop(&s,&e);
 				pop(&s,&d);
 				push(&s,d-e);
 				break;
 			case'*':
 				pop(&s,&e);
 				pop(&s,&d);
 				push(&s,d*e);
 				break;
 			case'/':
 				pop(&s,&e);
 				pop(&s,&d);
 				if(e != 0)
 				{
 				   push(&s,d/e);
 			     }
 			     else
 			     {
 			     	printf("除数为0\n");
 			     	return -1;
				  }
				  break;
 				
		 }
		 
		 
		 scanf("%c",&c);
	 }
	 pop(&s,&d);
	 printf("\n最终的计算结果为：%f\n",d);
	 return 0;
	  
 	
  }

在这里插入图片描述

//中缀转后缀

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<ctype.h>
#define STACK_SIZE    20
#define STACK         10
//#define MAXBUFFER     10
typedef char ElemType;
typedef struct
{
	ElemType *base;
	ElemType *top;
	int stack_size;
 } sqstack;
void  initstack(sqstack *s)
 {
 	s->base=(ElemType *)malloc(STACK_SIZE * sizeof(ElemType));
 	if(!s->base)
 	{
 		exit(0);
	 }
	 s->top=s->base;
	 s->stack_size=STACK_SIZE;
 }
 void push(sqstack *s,ElemType e)
 {
 	if(s->top - s->base>=s->stack_size)
 	{
 		s->base=(ElemType *)realloc(s->base,(s->stack_size+STACK) *sizeof(ElemType));
	 }
	if(!s->base)
	{
		exit(0);
	}
	*(s->top)=e;
 	s->top++;
 }
 void pop(sqstack *s,ElemType *e)
 {
 	if(s->top==s->base)
 	{
 		return ;
	 }
	 *e=*--(s->top);
 }
 int stacklen(sqstack s)
 {
 	return(s.top - s.base);
 }
 int main()
 {
 	sqstack s;
 	char c,e;
 	initstack(&s);
 	printf("请输入中缀表达式，以#作为结束标志：\n");
	 scanf("%c",&c);
	 while( c!= '#')
	 {
	 	if(c>='0'&& c<= '9')
	 	{
	 		printf("%c",c);
		 }
		 else if( ')' ==c)
		 {
		 	pop(&s,&e);
		 	while( '('!= e)
		 	{
		 		printf("%c",e);
		 		pop(&s,&e);
			 }
		 }
		 else if( '+'==c || '-'==c)
		 {
		 	if( !stacklen(s))
		 	
		 	{
		 		push(&s,c);
			 }
			 else
			 {
			 	do
			 	{
			 		pop(&s,&e);
			 		if('('==e)
			 		{
			 			push(&s,e);
					 }
					 else
					 {
					 	printf("%c",e);
					 }
				 }while(stacklen(s) &&'('!=e);
				 push(&s,c);
			 }
		 }
		 else if('*'==c || '/'==c ||'('==c)
		 {
		 	push(&s,c);
		 }
		 else
		 {
		 	printf("\n出错：输入格式错误！\n");
		 	return -1;
		 }
		 scanf("%c",&c);
	  } 
	  while( stacklen(s))
	  {
	  	pop(&s,&e);
	  	printf("%c",e);
	   } 
	  return 0;
  }

之后用中缀转后缀的算法加上后缀表达式计算的算法就可以实现中缀表达式的计算啦

3.栈在递归中的应用

  • 阶乘
  • 斐波那契数列
  • 回文数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//n的阶乘的递归与非递归算法
#include<stdio.h>
int fac1(int n)
{
	if(n==0||n==1)
	{
		return 1;
	}
	else
	{
		return n*fac1(n-1);
	}
 } 
 int fac2(int n)
 {
 	if(n==0||n==1)
 	{
 		return 1;
	 }
	 else
	 {
	 	int value =1;
	 	while(n>1)
	 	{
	 		value*=n;
	 		n--;
		 }
		 return value;
	 }
 }
 int main()
 {
 	printf("%d\n",fac1(5));
 	printf("%d\n",fac2(5));
 }

//斐波那契数列

#include<stdio.h>
int Fb(int i)
{
	if(i<2)
	  return i == 0? 0 :1;
	return Fb(i-1) + Fb(i-2);
 } 
 int main()
 {
 	int n;
 	printf("请输入月数n\n");
 	scanf("%d",&n);
 	printf("%d",Fb(n));
 }

//利用栈实现回文数

#include<stdio.h>
#include<string.h>
int main()
{
	char a[101],s[101];
	int i,len,mid,next,top;
	gets(a);
	len=strlen(a);
	mid=len/2-1;
	top=0;//栈的初始化
   for(i=0;i<=mid;i++)
	   {
	   	s[++top]=a[i];
		} 
     if(len%2==0)
	  {
	  	next=mid+1;
	   } 
	 else
	 {
	 	next=mid+2;
	 }
	   
	for(i=next;i<=len-1;i++)
	{
		if(a[i]!=s[top])
		  break;
		top--;
	}
	if(top==0)
	  printf("YES");
	else
	  printf("NO");
	getchar();getchar();
	return 0;
}

4.进制转化

  • 二进制转十进制
  • 二进制转八进制
  • 二进制转16进制
  • 十进制转n进制

1.二进制转十进制

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

#define STACK_SIZE    20
#define STACK         10
typedef char ElemType;
typedef struct
{
	ElemType *base;
	ElemType *top;
	int stack_size;
 } sqstack;
 void initstack(sqstack *s)
 {
 	s->base=(ElemType *)malloc(STACK_SIZE * sizeof(ElemType));
 	if(!s->base)
 	{
 		exit(0);
	 }
	 s->top=s->base;
	 s->stack_size=STACK_SIZE;
 }
 void push(sqstack *s,ElemType e)
 {
 	if(s->top - s->base>=s->stack_size)
 	{
 		s->base=(ElemType *)realloc(s->base,(s->stack_size+STACK) *sizeof(ElemType));
	 }
	if(!s->base)
	{
		exit(0);
	}
	*(s->top)=e;
 	s->top++;
 }
 void pop(sqstack *s,ElemType *e)
 {
 	if(s->top==s->base)
 	{
 		return ;
	 }
	 *e=*--(s->top);
 }
 int stacklen(sqstack s)
 {
 	return(s.top - s.base);
 }
 int main()
 {
 	ElemType a;
 	sqstack s;
 	int len,i,sum=0;
 	initstack(&s);
 	printf("请输入二进制数，输入#符号表示结束！\n");
 	scanf("%c",&a);
 	while( a != '#')
 	{
 		push(&s,a);
 		scanf("%c",&a);
	 }
	 getchar();//清理键盘缓冲区 ,把'\n'从缓冲区去掉 
	 len = stacklen(s);
	 printf("栈的当前容量是：%d\n",len);
	  for(i=0;i<len;i++)
	  {
	  	pop(&s,&a);
	  	sum = sum +(a-48) *pow(2,i);
	  }
	  printf("转化为十进制数是:%d\n",sum);
	 
	 
	 return 0;
 }

在这里插入图片描述

2.二进制转八进制

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef char ElemType;
typedef struct
{
     ElemType *top;
    ElemType *base;
    int stacksize;//指示栈当前最大可使用容量
}sqstack;

void Initstack(sqstack *s)
{
    s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!s->base)
        exit(0);

    s->top=s->base;
    s->stacksize=STACK_INIT_SIZE;
}

void push(sqstack *s,ElemType e)
{
    if(s->top-s->base>=s->stacksize)
    {
        s->base=(ElemType *)realloc(s->base,(STACKINCREMENT+s->stacksize)*sizeof(ElemType));
        if(!s->base)
            exit(0);
        s->top=s->base+s->stacksize;
        s->stacksize=s->stacksize+STACKINCREMENT;
    }
    *(s->top)=e;
    s->top++;
}

void pop(sqstack *s,ElemType *e)
{
    if(s->top==s->base)
        return;

    *e=*--(s->top);
}
//会对栈进行修改则传地址，不修改只是做测试等操作则只传数据即可
int stackLen(sqstack s)//这里传进来的是结构不是指针
{
    return (s.top-s.base);//相减的不是地址，是地址指向元素相减
}

int main()
{
   ElemType c;
   sqstack s1;
   sqstack s2;
   int len,i,j,sum=0;
   Initstack(&s1);
   printf("请输入二进制数，输入#表示结束\n");
   scanf("%c",&c);
   while(c!='#')
   {
       if(c=='0'||c=='1')
        push(&s1,c);
       scanf("%c",&c);
   }
   getchar();
   len=stackLen(s1);
   Initstack(&s2);
   for(i=0;i<len;i+=3)
   {
       for(j=0;j<3;j++)
       {
           pop(&s1,&c);
           sum=sum+(c-48)*pow(2,j);

           if(s1.base==s1.top)//若没有限制条件语句，在不足三位时，会因j<3继续进行循环，在空缺位补1造成错误
           {
               break;
           }
       }
       push(&s2,sum+48);//再次以字符形式传入
       sum=0;
   }
   printf("转化为八进制数为:");
while(s2.top!=s2.base){  //如果没有循环则只pop出一位


    pop(&s2,&c);
       printf("%c",c);

}
printf("(O)");
   return 0;
}

在这里插入图片描述

3.二进制转16进制

/*二进制转十六进制*/ 

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

#define  MAXSIZE  20
#define  ERROR    0
#define  OK       1

typedef int  Status;
typedef char Elemtype;

typedef struct{         //栈的静态分配存储结构 
	Elemtype elem[MAXSIZE];
	int top;
}SqStack;

void InitStack(SqStack *S)
{
	S->top=-1;         //top为整数且指向栈顶元素 
}

/*压栈操作*/
Status PushStack(SqStack *S,Elemtype e)
{
	if(S->top >= MAXSIZE-1)
	{
		return ERROR;
	}
	S->elem[++S->top]=e;
	return OK;
}

/*弹栈操作*/ 
Status PopStack(SqStack *S,Elemtype *e)
{
	if(S->top == -1)
	{
		return ERROR;
	}
	*e = S->elem[S->top--];
	return OK;
}

/*求栈长度*/
Status StackLength(SqStack *S)
{
	return S->top+1;
}

int main()
{
	int sum=0,value,i,j;
	Elemtype c;
	SqStack S,S1;
	
	InitStack(&S);
	
	printf("请输入二进制数，以#结束输入：\n");
	scanf("%c",&c);
	while( c != '#')
	{
		if( c == '1'|| c == '0')
		{
			value=PushStack(&S,c);
			if(!value)
			{
				printf("输入二进制数超过存储范围！\n");
				return ERROR;
			}
			scanf("%c",&c);
		}
		else
		{
			printf("非法输入！\n");
			return ERROR;
		}
	}
	
	getchar();                //把'\n'从缓冲区去掉 
	
	InitStack(&S1);
	
	int len=StackLength(&S);
	for(i=0 ; i<len ; i+=4)
	{
		for(j=0;j<4;j++)      //四位二进制数对应一位十六进制数 
		{
			PopStack(&S,&c);
			sum += ( c - 48 ) * pow( 2 , j );
			if(S.top == -1)
			{
				break;
			}	
		}
		
		switch(sum)
		{
			case 10: 
			case 11: 
			case 12: 
			case 13: 
			case 14: 
			case 15: sum+=55;break;//大于十转换成字母字符 
			default :sum+=48;      //小于十转换成数字字符 
			
		} 
		
		PushStack(&S1,sum);   //把转换的字符进行压栈 
		sum=0;                //从新进行下一个字符转换 
	} 
	
	
	printf("转化成十六进制是：");
	while( S1.top != -1)    //把转换好的十六进制数以字符形式进行弹栈 
	{
		PopStack(&S1,&c);
		printf("%c",c);	
	}
	printf("(H)\n"); 
	return 0;	
}

在这里插入图片描述

4.十进制转n进制

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

#define  ERROR   0
#define  OK      1
#define  INITSIZE 10
#define  INCREMENT 2

typedef int Status;
typedef int Elemtype;
typedef struct{
	Elemtype *base;
	Elemtype *top;
	int StackSize;
}SqStack;

Status InitStack(SqStack *S)
{
	S->base=(Elemtype*)malloc(sizeof(Elemtype)*INITSIZE);
	if(!S->base)
	{
		return ERROR;
	}
	S->top=S->base;
	S->StackSize=INITSIZE;
	return OK;
}

Status PushStack(SqStack *S,Elemtype e)
{
	if( S->top - S->base >= S->StackSize)
	{
		S->base=(Elemtype*)realloc(S->base,(S->StackSize+INCREMENT)*sizeof(Elemtype));
		if(!S->base)
		{
			return ERROR;
		}
		S->top = S->base+S->StackSize;
		S->StackSize+=INCREMENT;
	}
	*S->top=e;
	S->top++;
	return OK;
}

Status StackEmpty(SqStack *S)
{
	if(S->top == S->base)
	{
		return OK;
	}
	return ERROR;
}

Status PopStack(SqStack *S,Elemtype *e)
{
	if(S->top == S->base)
	{
		return ERROR;
	}
	*e=*--S->top;
	return OK;
}

void Fun_10_2_8_16(int number,int cet)
{
	SqStack S;
	Elemtype e;
	InitStack(&S);
	if(number==0) 
	{
		printf("转换后的%d进制数为:0",cet);
		return ; 
	}
	while(number)
	{
		PushStack(&S,number%cet);
		number=number/cet;
	}
	
	printf("转换后的%d进制数为：",cet); 
	while(!StackEmpty(&S))
	{
		PopStack(&S,&e);
		switch(e)          //整型数转成字符输出 
		{
			case 10:
			case 11:
			case 12:
			case 13:
			case 14:
			case 15: e+=55;break;
			default :e+=48;
		}
		printf("%c",e);
	}
}

int main()
{
	int number,cet;
	printf("请输入要转换的十进制数：");
	scanf("%d",&number);
	printf("请输入要转换的数制：");
	scanf("%d",&cet);
	Fun_10_2_8_16(number,cet);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

到这里,栈的应用部分整理完成,若有没有整理到的后续进行补充,之后会更新线性表链表的相关知识.

xwzj的小白
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构实验】栈的应用
06-15
实验三 栈的应用 1.实验目的： 熟悉栈的定义，栈的特点以及栈的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 对任意给定的一个中缀算术表达式,输出等价的后缀形式。
数据结构学习--栈及其应用
06-25
数据结构学习中，栈是一种非常基础且重要的结构，它被称为后进先出（LIFO，Last In First Out）的数据组织形式。在栈中，新添加的元素（压栈）会在最后，而取出元素（出栈）总是从这些新元素开始，即最先添加的元素...
【数据结构】 栈（Stack）的应用场景
最新发布
m0_71731682的博客
08-26 3336
栈（Stack）又名堆栈，作为一个== 先进后出== 的数据结构。它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
数据结构——栈
weixin_57525369的博客
05-07 4254
栈的概念 栈：是一个种特殊的线性表，只允许在固定的一端进行插入与删除元素的操作。在进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。栈中的元素遵守后进先出的原则。也叫先进后出。 举个例子：栈在我们的生活中的应用是经常见到的。我们大家在小时候应该都会玩过玩具枪，玩具枪里面的弹夹大家都不陌生吧，一颗一颗的子弹压入弹夹中，最后压入的子弹是最先被发射出来的。 在软件应用中，也是非常普遍的。比如我们在用浏览器浏览东西时，不管什么浏览器都会有一个“返回键”，点击后会按照你访问的顺序逆序后退...
数据结构-顺序栈实现
weixin_45651738的博客
05-03 388
头文件（SeqStack.h) #include<stdio.h> #include<malloc.h> #include<assert.h> #include<stdbool.h> #define STACK_INIT_SIZE 8 #define INC_SIZE 3 typedef int ElemType; typedef struct SeqStack { ElemType *base; int top; int capacity; }.
数据结构C代码——栈以及应用
m0_61641152的博客
05-10 397
栈的实现可以用指针和数组来实现，也可以用脚标作指针的功能。这里我们先用脚标来实现。 定义结构体： typedef struct CharStack{ int top;//栈顶的脚标 int data[STACK_MAX_SIZE];//用于存储数据的空间 }*CharStackPtr; 栈的初始化 CharStackPtr charStackInit(){ CharStackPtr tempStack = (CharStackPtr)malloc(sizeof(struct CharSta
ccc.rar_数据结构 栈的应用
09-21
在这个"ccc.rar_数据结构 栈的应用"压缩包中，我们重点关注的是栈这一特定的数据结构及其在实际问题中的应用。栈是一种线性数据结构，遵循“后进先出”（LIFO）的原则，形象地说，就像是一个堆叠的盘子，最后放上去...
ysbd.rar_数据结构_栈的应用
09-20
在ysbd.txt和www.pudn.com.txt这两个文件中，可能包含了关于数据结构和栈应用的具体示例、代码实现或者更深入的理论探讨。通过阅读这些文件，我们可以进一步理解栈在实际问题中的应用技巧和优化策略，提升我们的编程...
Java数据结构之栈的基本定义与实现方法示例
08-29
Java数据结构之栈的基本定义与实现方法示例 Java数据结构之栈是一种特殊的线性表，它只能在某一端插入和删除元素，按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶...
数据结构中栈的应用.pdf
08-07
#资源达人分享计划#
数据结构栈的操作及应用
m0_53975470的博客
10-17 215
关于栈的一些代码以及一个oj题
常用数据结构栈的应用—-表达式求值
weixin_30813225的博客
09-13 543
常用数据结构栈的应用—-表达式求值 常用数据结构栈的应用-表达式求值 栈 表达式求值 后缀表达式求值 中缀表达式转后缀表达式 代码示例 栈 栈是常用的数据结构，栈又称堆栈，是一种受限的线性表。其限制是允许在表中的一端进行插入和删除元素。栈中的元素符合后进先出（FILO）的性质。允许插入和删除元素的一端被称为栈顶，另一端被称...
数据结构-栈及其应用
qq_43627079的博客
11-03 460
一 . 栈 栈的逻辑结构 ：限定仅在表尾进行插入和删除操作的线性表 允许插入和删除的一端称为栈顶，另一端称为栈底。 空栈是不含任何数据结构的栈 。 1.栈的具体操作 stack S //定义一个整型的数据栈 Spush()//插入数据 S.top()//取栈顶 S.pop()/删除栈顶 S.empty()//栈是否为空 栈的具体应用–后缀表达式 从左到右对后缀表达式字符串进行处理，每次处理一个符...
数据结构——栈的应用（表达式求值）（C语言）
热门推荐
Sup_klz的博客
04-16 2万+
char Precede(char t1, char t2)函数用于输出t1,t2两个运算符的优先级（t1为先出现的运算符（已经压入栈OPTR中），t2为后出现的运算符）char Precede(char t1, char t2){ int i,j; char pre[][7]={ //运算符之间的优先级制作成一张表格 {'>
数据结构与算法——栈的作用及应用
无意摘花
02-15 2306
作用： 栈的引入简化了程序设计的问题，划分了不同的关注层次，使得思考范围缩小，更加聚焦于要解决的问题核心。反之，像数组等，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。 应用一：递归，斐波那契数列 /* 斐波那契序列的两种表示 */ #include /* 迭代表示法 */ /* 斐波那契序列的两种表示 */ #include /* 迭代表示法 */ voi
数据结构——栈的使用
请赐教
01-30 2670
TOJ 1218 描述 请你定义一个栈，可以对栈进行“压入堆栈”、“弹出栈顶元素”、“清空堆栈”、“获取栈顶元素”等操作。键盘输入一些命令，可以执行上述操作。本题中，栈元素均为整数。栈的最大元素个数为1000。 输入 输入各个命令，它们对应的格式如下： 压入堆栈：push a，a代表压入堆栈的元素，这里push和元素之间用空格分隔。 清空堆栈：clear
数据结构(5)--栈的定义以及相关操作的实现
小白的专栏
02-05 6992
 参考书籍：数据结构（C语言版） 严蔚敏 吴伟民编著 清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.栈的定义 栈（stack）是限定在表尾一端进行插入或删除操作的线性表。在栈中，允许插入和删除操作的一端称为栈顶（top），而另一端称为栈底（bottom）。不含元素的栈称为空栈。 在栈的运算...
栈与队列的数据结构详解及应用
"这篇资料主要介绍了算法设计中的栈和队列数据结构，通过实例解析了栈的应用，并提供了栈和队列的类型定义及操作方法。" 在计算机科学中，栈和队列是两种基础但非常重要的数据结构。它们都是线性表的变种，但在操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值