数据结构之栈的应用

最新推荐文章于 2023-08-26 10:48:44 发布
最新推荐文章于 2023-08-26 10:48:44 发布
阅读量598 收藏 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
    评论
专栏目录
数据结构栈的应用
chy2939960881的博客
05-10 727
（1）建立空栈（2）初始化（3）打印（4）进栈（功能表达）（5）出栈（功能表达）（6）进出栈（功能实现）（7）检验括号是否匹配（功能实现）（8）检验括号是否匹配（功能表达） 1建立空栈 typedef struct CharStack { int top; int data[STACK_MAX_SIZE]; } 2初始化 CharStackPtr charStackInit() { CharStackPtr resultPtr = (CharStackPtr)malloc
数据结构-栈的应用
aids1990的博客
07-16 1377
栈有一个很重要的应用：在程序设计语言中讲了递归。那么什么是递归呢？当你往镜子前面一站，镜子里面就有一个你的像。但你试过两面镜子一起照吗？如果A、B两面镜子互相面对面放着，你往中间一站，嘿，两面镜子都有你的千百个“化身”，为什么会有这么奇妙的现象呢？原来，A镜子里有B镜子的像，B镜子里也有A镜子的像，这样反反复复，就会产生一连串的“像中像”。这是一种递归现象。我们先来看一个经典的递归例子：...
数据结构 栈的应用
i123i456i的博客
06-26 431
每当用户浏览一个新页面时，该页面的信息会被压入栈中，当用户点击后退按钮时，栈顶的页面信息被弹出，用户就回到了上一个访问的页面。每次执行一个编辑操作时，相关的信息被保存在栈中，当用户要撤销操作时，栈顶的信息被弹出，恢复到之前的状态。1、函数调用：在程序中，每次函数被调用时，相关的信息（如返回地址、局部变量等）都会被压入栈中，函数执行完毕后，这些信息又会被弹出，以返回上一级调用。2、表达式求值：在计算表达式时，可以使用栈来存储操作数和运算符。通过遍历表达式，并按照运算符的优先级进行计算，最终得到表达式的结果。
数据结构之栈的使用
公众号：风景邮递Yuan的博客
03-24 1097
栈的特点是后进先出，即最后进入栈的元素会先被弹出栈。同时，栈的实现也是许多其他数据结构和算法的基础，例如队列、图的深度优先搜索等，因此深入了解栈的原理和实现对于进一步学习计算机科学非常有帮助。栈的溢出指在入栈操作时，栈已经满了，无法再继续入栈，这时应该进行相应的处理，例如扩容操作；栈的下溢指在出栈操作时，栈已经为空，无法继续出栈，这时也需要进行相应的处理，例如抛出异常或者返回默认值。总的来说，栈可用于许多场景，如括号匹配、计算表达式等，这些应用需要对栈的性质有深入理解，并熟练掌握栈相关的算法和操作。
【数据结构实验】栈的应用
山风不打咩的博客
04-15 1930
栈也称为堆栈，是一种先进后出，删除和插入都在栈顶操作的线性表。 特性：先进后出，后进先出。 最先放入栈的最后被拿出来，最后放入栈的内容最先被拿出来。
数据结构——栈的应用
m0_57484470的博客
10-23 3309
本文采用C语言具体实现栈结构的经典应用样例：数制转换，括号匹配，行编辑程序，表达式求值问题。
数据结构的应用
shenjingbiang的博客
03-11 908
假设有A、B、C、D、E五个高等院校进行田径对抗赛，各院校的单项成绩均已存入计算机，并构成一张表，表中每一行的形式为 项目名称 性别 校名 成绩 得分 编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。 举了一组简单的例子，实现了下面的程序。例子为：设A高校在X项目中，有一女同学取得了100分的成绩。然
ccc.rar_数据结构 栈的应用
09-21
在这个"ccc.rar_数据结构 栈的应用"压缩包中，我们重点关注的是栈这一特定的数据结构及其在实际问题中的应用。栈是一种线性数据结构，遵循“后进先出”（LIFO）的原则，形象地说，就像是一个堆叠的盘子，最后放上去...
ysbd.rar_数据结构_栈的应用
09-20
在ysbd.txt和www.pudn.com.txt这两个文件中，可能包含了关于数据结构和栈应用的具体示例、代码实现或者更深入的理论探讨。通过阅读这些文件，我们可以进一步理解栈在实际问题中的应用技巧和优化策略，提升我们的编程...
数据结构学习--栈及其应用
06-25
数据结构学习中，栈是一种非常基础且重要的结构，它被称为后进先出（LIFO，Last In First Out）的数据组织形式。在栈中，新添加的元素（压栈）会在最后，而取出元素（出栈）总是从这些新元素开始，即最先添加的元素...
Java数据结构之栈的基本定义与实现方法示例
08-29
Java数据结构之栈的基本定义与实现方法示例 Java数据结构之栈是一种特殊的线性表，它只能在某一端插入和删除元素，按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶...
栈的应用（三种应用）
weixin_73193549的博客
08-23 2863
栈的引入简化了程序设计的问题，使得我们不需要像数组一样关注下标的增减，随机位置的插入与删除，在一些情况下可以以较小的时间复杂度解决问题，下面介绍一下栈常用的三个场景：递归，后缀表达式以及浏览器的前进后退。由图可知，显然符合栈这样的数据结构，简单的说，在前行阶段，对于每一层递归，函数的局部变量，参数值以及返回地址都被压入栈中；浏览器使用栈来存储用户访问的页面，每次访问新页面时，将其压入栈中，点击后退按钮时，从栈顶弹出页面。在计算机中，中缀表达式是人们常用的表达式形式，但计算机在计算表达式时，为了方便处理。
【数据结构】 栈（Stack）的应用场景
最新发布
m0_71731682的博客
08-26 3346
栈（Stack）又名堆栈，作为一个== 先进后出== 的数据结构。它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
数据结构-栈及栈的应用
初始化的博客
07-19 4537
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
实验三栈及其应用
qq_51233271的博客
12-29 443
实验三栈及其应用 1. (必做题) 设计并验证以下算法：设一个算术表达式中包含圆括号、方括号和花括号，判断其中的括号是否匹配。 (1) 算术表达式中可以包含三种括号“（”和“）”、“[”和“]”、“{”和“}”，并且这三种括号可以按任意的次序嵌套使用。比如，…[…{…}[…]]…(…)…。 (2) 设置一个运算符栈OPTR。当遇到的‘（’、‘[’或‘{’时进栈；当遇到‘（’、‘[’或‘{’时，判断栈顶是否为相应的括号，若是则退栈继续执行，否则提示出错并结束。 (3) 要求由键盘输入包括‘（’、‘[’或‘{’
数据结构算法之关键路径
qq_43607916的博客
07-14 6401
关键路径 文章目录： 基本概念 关键路径的构造过程 关键路径的特点 1.基本概念 首先要了解AOE网和关键路径的基本概念 这里详细说明一下，AOE网和AOV网的区别和联系： 联系：都代表的是有向无环图。 区别： 1.AOE网的边表示活动，边有权值，边一般代表的是活动持续时间，顶点表示事件，事件是图中新活动开始或者旧活动结束的标志。 2.AOV网的顶点表示活动，边无权值，边代表活动之间的先后关系。 3.对于一个表示工程的AOE网，只存在一个入度为0的顶点，称为源点，表示整个工程的开始；也只存在一个出度为
栈与队列的数据结构详解及应用
"这篇资料主要介绍了算法设计中的栈和队列数据结构，通过实例解析了栈的应用，并提供了栈和队列的类型定义及操作方法。" 在计算机科学中，栈和队列是两种基础但非常重要的数据结构。它们都是线性表的变种，但在操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值