数据结构之顺序栈SqStack

最新推荐文章于 2022-10-26 22:33:37 发布
最新推荐文章于 2022-10-26 22:33:37 发布
阅读量1w 收藏 32
点赞数 7
分类专栏： 课本学习 文章标签： 数据结构 顺序栈 基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010568270/article/details/52725852
版权


顺序栈SqStack


基本操作


Status InitStack()//构造一个空栈S
Status DestroyStack()//销毁栈S，S不再存在
Status ClearStack()//把S置为空栈
Status StackEmpty()//若S为空栈，则返回true，否则返回false
int StackLength()//返回S的元素个数，即栈的长度
Status GetTop(SElemType &e)//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR
Status Push(SElemType e)//插入元素e为新的栈顶元素
Status Pop(SElemType &e)//若栈不空，则删除S的栈顶元素，并用e返回其值，并返回OK，否则返回ERROR
Status StackTraverse(int p)//从栈底到栈顶依次对栈中每个元素调用函数visit().一旦visit()失败则操作失败


几个小程序（代码正误检验，数制转换，括号匹配检验，行编辑程序）


CheckStackCode();//测试Stack代码正确性
Conversion();//数制转换
BracketsMatching();//括号匹配的检验
LineEdit();//行编辑程序



//
//by coolxxx
//#include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<iomanip>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<bitset>
#include<memory.h>
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#include<stdbool.h>
#include<math.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define abs(a) ((a)>0?(a):(-(a)))
#define lowbit(a) (a&(-a))
#define sqr(a) ((a)*(a))
#define swap(a,b) ((a)^=(b),(b)^=(a),(a)^=(b))
#define mem(a,b) memset(a,b,sizeof(a))
#define eps (1e-10)
#define J 10000
#define mod 1000000007
#define MAX 0x7f7f7f7f
#define PI 3.14159265358979323
#pragma comment(linker,"/STACK:1024000000,1024000000")
#define N 104

using namespace std;
typedef long long LL;
/*
double anss;
LL aans,sum;
int cas,cass;
int n,m,lll,ans;
*/


const int OK=1;
const int ERROR=0;
const int INFEASIBLE=-1;
const int STACK_INIT_SIZE=100;//存储空间初始分配量
const int STACKINCREMENT=10;//存储空间分配增量
typedef int Status;
typedef int SElemType;

Status OutputInt(SElemType e);
Status OutputChar(SElemType e);
typedef struct
{
	SElemType *base;//栈构造之前和销毁之后，base的值为NULL
	SElemType *top;//栈顶指针
	int stacksize;//当前已分配的存储空间，以元素为单位
	
	Status InitStack()//构造一个空栈S
	{
		base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
		if(!base)exit(OVERFLOW);//存储分配失败
		top=base;
		stacksize=STACK_INIT_SIZE;
		return OK;
	}//InitStack
	
	Status DestroyStack()//销毁栈S，S不再存在
	{
		free(base);
		base=NULL;
		top=NULL;
		stacksize=0;
		return OK;
	}//DestroyStack
	
	Status ClearStack()//把S置为空栈
	{
		top=base;
		return OK;
	}//ClearStack
	
	Status StackEmpty()//若S为空栈，则返回true，否则返回false
	{
		if(top==base)return true;
		return false;
	}//StackEmpty
	
	int StackLength()//返回S的元素个数，即栈的长度
	{
		return top-base;
	}//StackLength
	
	Status GetTop(SElemType &e)//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR
	{
		if(top==base)return ERROR;
		e=*(top-1);
		return OK;
	}//GetTop
	
	Status Push(SElemType e)//插入元素e为新的栈顶元素
	{
		if(top-base>=stacksize)//栈满，追加存储空间
		{
			base=(SElemType *)realloc(base,(stacksize+STACKINCREMENT)*sizeof(SElemType));
			if(!base)exit(OVERFLOW);//存储分配失败
			top=base+stacksize;
			stacksize+=STACKINCREMENT;
		}
		(*top++)=e;
		return OK;
	}//Push
	
	Status Pop(SElemType &e)//若栈不空，则删除S的栈顶元素，并用e返回其值，并返回OK，否则返回ERROR
	{
		if(top==base)return ERROR;
		e=(*--top);
		return OK;
	}//Pop
	
	Status StackTraverse(int p)//从栈底到栈顶依次对栈中每个元素调用函数visit().一旦visit()失败则操作失败
	{
		SElemType *i=base;
		Status (*visit)(SElemType);
		if(p==1)visit=OutputInt;
		else if(p==0)visit=OutputChar;
		while(top>i)
			visit(*i++);
		puts("");
		return OK;
	}//StackTraverse
}SqStack;

Status OutputInt(SElemType e)
{
	printf("%d ",e);
	return OK;
}
Status OutputChar(SElemType e)
{
	printf("%c",e);
	return OK;
}


void CheckStackCode()
{
	typedef int SElemType;
	int i;
	SqStack S;
	SElemType e;
	if(S.InitStack()==OK)
	{
		for(i=1;i<=12;i++)
			S.Push(i);
	}
	printf("栈中元素依次为：");
	S.StackTraverse(1);
	S.Pop(e);
	printf("弹出的栈顶元素 e=%d\n",e);
	printf("栈空否：%d(1：空 0：否)\n",S.StackEmpty());
	S.GetTop(e);
	printf("栈顶元素 e=%d 栈的长度为%d\n",e,S.StackLength());
	S.Push(13);
	printf("栈中元素依次为：");
	S.StackTraverse(1);
	S.GetTop(e);
	printf("栈顶元素 e=%d 栈的长度为%d\n",e,S.StackLength());
	S.DestroyStack();
	printf("销毁栈后，S.top=%d  S.base=%d  S.stacksize=%d\n",S.top,S.base,S.stacksize);
}

void Conversion()//对于输入的任意一个非负十进制整数n，打印输出与其等值的八进制数
{
	typedef int SElemType;
	int n;
	SqStack S;
	SElemType e;
	
	S.InitStack();//构造空栈
	scanf("%d",&n);
	while(n)
	{
		S.Push(n%8);
		n/=8;
	}
	while(!S.StackEmpty())
	{
		S.Pop(e);
		printf("%d",e);
	}
	puts("");
	
	S.DestroyStack();
}

void BracketsMatching()//三种括号()[]{}，检验是否合法
{
	
	char s[N];
	SqStack S;
	SElemType e;
	int i;
	S.InitStack();
	scanf("%s",s);
	
	for(i=0;i<strlen(s);i++)
	{
		if(s[i]=='(' || s[i]=='{' || s[i]=='[')
			S.Push(s[i]);
		else if(s[i]==')' || s[i]=='}' || s[i]==']')
		{
			if(S.GetTop(e) && ((e=='(' && s[i]==')') || (e=='[' && s[i]==']') || (e=='{' && s[i]=='}')))
				S.Pop(e);
			else
			{
				puts("NO");
				S.DestroyStack();
				return;
			}
		}
	}
	if(S.StackEmpty())puts("YES");
	else puts("NO");
	S.DestroyStack();
}

void LineEdit()//从终端接收一行并传送至调用过程的数据区，#为退格符，@为退行符
{
	int i;
	char ch;
	SqStack S;
	SElemType e;
	S.InitStack();
	while(ch!=EOF)
	{
		for(ch=getchar();ch!=EOF && ch!='\n';ch=getchar())
		{
			if(ch=='#')S.Pop(e);
			else if(ch=='@')S.ClearStack();
			else S.Push(ch);
		}
		S.StackTraverse(0);
		S.ClearStack();
	}
	S.DestroyStack();
}


int main()
{
	#ifndef ONLINE_JUDGEW
	freopen("1.txt","r",stdin);
//	freopen("2.txt","w",stdout);
	#endif
	int i,j,k;
//	init();
//	for(scanf("%d",&cass);cass;cass--)
//	for(scanf("%d",&cas),cass=1;cass<=cas;cass++)
//	while(~scanf("%s",s))
/*
	while(~scanf("%d%d",&n,&m))
	{
		
	}
	*/
	
	CheckStackCode();//测试Stack代码正确性
	
	Conversion();//数制转换
	
	BracketsMatching();//括号匹配的检验
	
	LineEdit();//行编辑程序
	
	return 0;
}
/*
//

//
*/


马踏棋盘问题（NxN）

暴力(顺序栈实现)

//
//by coolxxx
//#include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<iomanip>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<bitset>
#include<memory.h>
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#include<stdbool.h>
#include<math.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define abs(a) ((a)>0?(a):(-(a)))
#define lowbit(a) (a&(-a))
#define sqr(a) ((a)*(a))
#define swap(a,b) ((a)^=(b),(b)^=(a),(a)^=(b))
#define mem(a,b) memset(a,b,sizeof(a))
#define eps (1e-10)
#define J 10000
#define mod 1000000007
#define MAX 0x7f7f7f7f
#define PI 3.14159265358979323
#pragma comment(linker,"/STACK:1024000000,1024000000")
#define N 8
using namespace std;
typedef long long LL;
double anss;
LL aans;
int cas,cass;
LL n,m,lll,ans;
int a[N][N];
bool u[N][N];
int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};

const int OK=1;
const int ERROR=0;
const int INFEASIBLE=-1;
const int STACK_INIT_SIZE=10000;//存储空间初始分配量
const int STACKINCREMENT=10000;//存储空间分配增量
typedef int Status;

typedef struct
{
	int x,y,dir;
}SElemType;

Status OutputInt(SElemType e);
Status OutputChar(SElemType e);
typedef struct
{
	SElemType *base;//栈构造之前和销毁之后，base的值为NULL
	SElemType *top;//栈顶指针
	int stacksize;//当前已分配的存储空间，以元素为单位
	
	Status InitStack()//构造一个空栈S
	{
		base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
		if(!base)exit(OVERFLOW);//存储分配失败
		top=base;
		stacksize=STACK_INIT_SIZE;
		return OK;
	}//InitStack
	
	Status DestroyStack()//销毁栈S，S不再存在
	{
		free(base);
		base=NULL;
		top=NULL;
		stacksize=0;
		return OK;
	}//DestroyStack
	
	Status ClearStack()//把S置为空栈
	{
		top=base;
		return OK;
	}//ClearStack
	
	Status StackEmpty()//若S为空栈，则返回true，否则返回false
	{
		if(top==base)return true;
		return false;
	}//StackEmpty
	
	int StackLength()//返回S的元素个数，即栈的长度
	{
		return top-base;
	}//StackLength
	
	Status GetTop(SElemType &e)//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR
	{
		if(top==base)return ERROR;
		e=*(top-1);
		return OK;
	}//GetTop
	
	Status Push(SElemType e)//插入元素e为新的栈顶元素
	{
		if(top-base>=stacksize)//栈满，追加存储空间
		{
			base=(SElemType *)realloc(base,(stacksize+STACKINCREMENT)*sizeof(SElemType));
			if(!base)exit(OVERFLOW);//存储分配失败
			top=base+stacksize;
			stacksize+=STACKINCREMENT;
		}
		(*top++)=e;
		return OK;
	}//Push
	
	Status Pop(SElemType &e)//若栈不空，则删除S的栈顶元素，并用e返回其值，并返回OK，否则返回ERROR
	{
		if(top==base)return ERROR;
		e=(*--top);
		return OK;
	}//Pop
	
	Status StackTraverse(int p)//从栈底到栈顶依次对栈中每个元素调用函数visit().一旦visit()失败则操作失败
	{
		SElemType *i=base;
		Status (*visit)(SElemType);
		if(p==1)visit=OutputInt;
		else if(p==0)visit=OutputChar;
		while(top>i)
			visit(*i++);
		puts("");
		return OK;
	}//StackTraverse
}SqStack;
Status OutputInt(SElemType e)
{
	printf("%d ",e);
	return OK;
}
Status OutputChar(SElemType e)
{
	printf("%c",e);
	return OK;
}

SqStack S;
void print()
{
	int i,j;
	for(i=0;i<N;i++,puts(""))
		for(j=0;j<N;j++)
			printf("%d ",a[i][j]);
	puts("");
}
int main()
{
	#ifndef ONLINE_JUDGEW
	freopen("1.txt","r",stdin);
//	freopen("2.txt","w",stdout);
	#endif
	int i,j,k;
	int x,y,z,xx,yy;
//	init();
//	for(scanf("%d",&cass);cass;cass--)
//	for(scanf("%d",&cas),cass=1;cass<=cas;cass++)
//	while(~scanf("%s",s))
	while(~scanf("%d%d",&n,&m))
	{
		mem(a,0);mem(u,0);
		S.InitStack();
		SElemType e,to;
		e.x=n,e.y=m,e.dir=-1;
		u[n][m]=1;
		S.Push(e);
		loop : while(S.top-S.base<N*N && !S.StackEmpty())
		{
			SElemType & now=*(S.top-1);
			for(++now.dir;now.dir<8;now.dir++)
			{
				xx=now.x+dx[now.dir],yy=now.y+dy[now.dir];
				if(xx>=0 && xx<N && yy>=0 && yy<N && !u[xx][yy])
				{
					u[xx][yy]=1;
					to.x=xx,to.y=yy,to.dir=-1;
					S.Push(to);
					goto loop;
				}
			}
			S.Pop(e);
			u[e.x][e.y]=0;
		}
		if(S.StackEmpty()){puts("No Answer\n");continue;}
		SElemType *id;
		for(id=S.base,cas=0;id!=S.top;id++)
		{
			e=(*id);
			a[e.x][e.y]=++cas;
		}
		print();
		S.DestroyStack();
	}
	return 0;
}

马踏棋盘贪心优化

// 
//by coolxxx
//#include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<iomanip>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<bitset>
#include<memory.h>
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//#include<stdbool.h>
#include<math.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define abs(a) ((a)>0?(a):(-(a)))
#define lowbit(a) (a&(-a))
#define sqr(a) ((a)*(a))
#define swap(a,b) ((a)^=(b),(b)^=(a),(a)^=(b))
#define mem(a,b) memset(a,b,sizeof(a))
#define eps (1e-10)
#define J 10000
#define mod 1000000007
#define MAX 0x7f7f7f7f
#define PI 3.14159265358979323
#pragma comment(linker,"/STACK:1024000000,1024000000")
#define N 8
using namespace std;
typedef long long LL;
double anss;
LL aans;
int cas,cass;
LL n,m,lll,ans;
int a[N][N];
bool u[N][N];
int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};
struct xxx
{
	int c,num;
};
bool cmp(xxx aa,xxx bb)
{
	return aa.c<bb.c;
}
void print()
{
	int i,j;
	for(i=0;i<N;i++,puts(""))
		for(j=0;j<N;j++)
			printf("%d ",a[i][j]);
	puts("");
}
void cal(int x,int y,xxx d[])
{
	int i,j,xx,yy,x1,y1;
	for(i=0;i<8;i++)
	{
		d[i].c=0;d[i].num=i;
		xx=x+dx[i],yy=y+dy[i];
		if(xx>=0 && xx<N && yy>=0 && yy<N && !u[xx][yy])
		{
			d[i].c++;
			for(j=0;j<8;j++)
			{
				x1=xx+dx[j],y1=yy+dy[j];
				if(x1>=0 && x1<N && y1>=0 && y1<N && !u[x1][y1])
				{
					d[i].c++;
				}
			}
		}
	}
}
void dfs(int x,int y,int top)
{
	if(top==65)
	{
		print();
		lll++;
		return;
	}
	int i,j,xx,yy;
	xxx d[8];
	cal(x,y,d);
	sort(d,d+8,cmp);
	for(i=0;i<8;i++)
	{
		if(d[i].c==0)continue;
		j=d[i].num;
		xx=x+dx[j],yy=y+dy[j];
		if(xx>=0 && xx<N && yy>=0 && yy<N && !u[xx][yy])
		{
			u[xx][yy]=1;
			a[xx][yy]=top;
			dfs(xx,yy,top+1);
			if(lll==cas)return;
			u[xx][yy]=0;
			a[xx][yy]=0;
		}
	}
}
int main()
{
	#ifndef ONLINE_JUDGEW
//	freopen("1.txt","r",stdin);
//	freopen("2.txt","w",stdout);
	#endif
	int i,j,k;
	int x,y,z,xx,yy;
//	init();
//	for(scanf("%d",&cass);cass;cass--)
//	for(scanf("%d",&cas),cass=1;cass<=cas;cass++)
//	while(~scanf("%s",s))
	puts("输入起点坐标和需要的解的数量");
	while(~scanf("%d%d",&n,&m))
	{
		scanf("%d",&cas);
		j=clock();
		mem(a,0);mem(u,0);lll=0;
		a[n][m]=1;u[n][m]=1;
		dfs(n,m,2);
		k=clock();
		printf("用时 %.3lf s\n",0.001*(k-j));
		puts("输入起点坐标和需要的解的数量");
	}
	return 0;
}


为了写的快就随便优化没怎么细想，如果觉得我的算法复杂度还是太高可以转http://blog.csdn.net/bone_ace/article/details/41579957




Coolxxs
关注
专栏目录
SqStack.cpp
09-17
c语言实现栈的各种操作，包括初始化栈、压栈操作、取栈顶、出栈操作、销毁一个栈。并带有十进制转八进制，括号匹配等运用栈的案例，适用于数据结构初学者。
SqStack
10-30 2268
#include using namespace std; #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 //存储空间初始分配量 #define STACKINCREMENT 10 //存储空间分配增量 t
c语言sqstack的用法结构体,数据结构线性表的操作与实现
weixin_39528525的博客
05-21 2659
线性表的基本操作与实现typedef int ElemType; typedef struct {int top; /*类型定义*/ ElemType *base; int stacksize; }sqstack;void initstack(sqstack *s) {s->base=(ElemType*)malloc(INITSIZE*...
c语言sqstack的用法结构体,数据结构线性表操作与实现.doc
weixin_33268861的博客
05-21 486
数据结构线性表操作与实现任课教师：《数据结构与算法》(2011-2012学年第1学期)实验报告学号：姓名：班级：实验一 线性表的基本操作与实现一、实验目的复习C语言中指针、结构体、子程序调用等基础知识。掌握线性表的基本结构和操作方法，主要包括：顺序表、链表、循环链表、栈、队列等的基本操作与实现方法，培养学生灵活使用数据结构解决实际问题的能力。、要求复习C语言中指针的用法，特别是结构体的指针的用法...
漫话数据结构-顺序栈.pptx
最新发布
11-03
顺序栈是一种特殊的数据结构，属于线性表的范畴。线性表是由n个相同类型元素构成的有限序列，而在顺序栈中，这些元素是按照它们被添加的顺序进行存储的，即后进先出（Last In First Out，简称LIFO）。顺序栈通常通过...
顺序栈ADT数据结构代码
12-02
顺序栈（Sequential Stack）是计算机科学中一种基本的数据结构，它是线性表的一种特殊形式，具有后进先出（LIFO）的特点。在顺序栈中，元素存储在一块连续的内存区域，通常通过数组来实现。本文将详细介绍顺序栈的...
数据结构 顺序栈
05-30
顺序栈是数据结构中的一种基本类型，属于线性数据结构。本篇我们将深入探讨顺序栈的概念、实现和应用。 顺序栈，顾名思义，是按照元素在内存中的顺序存储数据的栈。在计算机内存中，顺序栈通常采用数组来实现。与...
数据结构遍历顺序栈_数据结构和算法-栈结构
weixin_35660371的博客
02-12 2482
栈的定义栈是一种后进先出的数据结构。栈是限制插入和删除只能在一个位置上的线性表。允许删除和插入的一端位于表的末端，叫做栈顶。不允许删除和插入的另一端叫做栈底。对栈的基本操作有push(压栈)和pop(出栈)。图示：栈的实现栈的实现主要包括两种方式：顺序栈和链表栈。顺序栈使用数组来实现。缺点：需要提前声明一个数组大小。如果数组不够大，就有可能发生越界问题。如果数组过大，则可能浪费一定的空间。栈的定义...
数据结构《顺序栈》知识点详解+C语言完整代码-超详细
susuwhsbbs的博客
01-15 4940
顺序栈栈1. 定义2. 逻辑结构3. 存储结构4. 运算规则5. 实现方式实现1. 顺序栈的表示2. 结构体3.初始化4.入栈5.出栈6. 去栈顶元素7.求长8.打印9.全部代码10.运行图栈的应用举例1.数制转换2.括号匹配的检验3.行编辑程序问题4.迷宫求解5.表达式求值6.实现递归 栈 1. 定义 栈：只能在表的一端（栈顶）进行插入和删除运算的线性表。 2. 逻辑结构 与线性表相同，仍为一对一关系。 3. 存储结构 用顺序栈或链栈存储均可，但以顺序栈更常见。 4. 运算规则 只能在栈顶运算，且访问结点
顺序栈的实现(SqStack, C++版)
YangJq的专栏
10-24 3863
/* stack.h */#ifndef __SQSTACK_H__#define __SQSTACK_H__ 1#include extern "C" { void exit(int); }const int nDefaultStackSize = 50; //缺省Stack元素个数//以下为栈的顺序存储结构(顺序栈)的C++类定义template //声明为模板类class
[栈] 顺序栈SqStack-C实现
geodoer
08-25 3993
C语言实现顺序栈，并进行了封装，可保存命名为’SqStack.h’，即可调用 // Desc:顺序栈 // Time:20180819 // Vesion:0.0.1 #ifndef BASE #define BASE #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #defin...
数据结构SqStack 数组实现栈
weixin_43943281的博客
09-26 818
数据结构SqStack 数组实现栈 #include<stdio.h> #include<iostream> #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef struct SqStack { int* base; int* top; int stacksize; void Init(SqS...
栈statck
huluwababy的博客
05-31 257
栈是限定仅在表头进行插入和删除操作的线性表。 希望这段代码可以帮助 #include #include   struct node { int data; struct node *next; };   struct stack { struct node *top; struct node *end; }; //压栈 void push(struct sta
数据结构——栈
TTTSEP9TH2244的博客
01-16 1759
一、实验目的 理解和掌握栈的类型定义方法。 掌握栈中的基本运算，包括创建、判空及判满、出栈/入栈等基本操作。 学习利用栈解决实际问题 二、实验要求 【项目1 – 验证性实验：建立顺序栈、链栈】 【要求】： 1、头文件sqstack.h中定义数据结构并声明用于完成基本运算的函数。对应基本运算的函数包括： 2、在sqstack.cpp中实现这些函数 3、在main函数中完成测试，包括如下内容： (1)初始化栈s (2)判断s栈是否为空 (3)依次进栈元素a,b,c,d,e (4)判断s栈是否为空 (5)输出
数据结构：栈和队列
weixin_61926920的博客
10-26 1029
栈及其基本运算 栈的定义 栈的相关概念 逻辑结构 ：与同线性表相同，仍为一对一的关系 存储结构：用顺序栈或链栈存储均可，但以顺序栈更常见 运算规则：只能在栈顶运算，且访问结点时依照 （LIFO）的原则 实现方式，关键是遍写入栈和出栈的函数，具体实现依顺序栈或链栈的不同而不同
数据结构(C语言版)严蔚敏-＞顺序栈的定义、利用顺序栈解决有效的括号
坚持不懈的大白的博客
07-04 1021
1. 利用栈解决有效的括号问题 有效的括号题目来自leetcode，链接为：有效的括号，题目难度简单。 思路，首先判断当前栈是否为空，如果为空，则将当前字符入栈；如果栈不为空，则得到栈顶字符元素，将得到的栈顶字符元素与当前字符进行有效括号比较，不过不满足有效括号，则将当前栈入栈，否则将当前栈顶字符元素出栈，以此类推即可，最后判断栈是否为空，为空则字符串有效，否则无效。 ...
【数据结构】栈
colorfulshark
03-27 659
【1】栈的概念栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈）， 允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中 没有元素时称为“空栈”。 【2】特点 ##后进先出（LIFO）。 【3】顺序栈（sqstack）定义数据类型 定义结构体 top = 0， top = -1 创建一个空的栈 判断栈是否为空 判断栈是否为满 入栈（压栈） 出栈（弹栈） 打印栈的数据 【4】链式栈
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值