数据结构——第三章（栈和队列）

最新推荐文章于 2022-11-02 21:45:24 发布

小七fighting

最新推荐文章于 2022-11-02 21:45:24 发布

阅读量514

点赞数

分类专栏：数据结构文章标签：队列数据结构栈

本文链接：https://blog.csdn.net/icu13996/article/details/113396905

版权

数据结构专栏收录该内容

8 篇文章 3 订阅

订阅专栏

本文详细介绍了栈和队列这两种数据结构的概念、顺序和链式存储实现，以及相关操作如入栈、出栈、入队、出队等。栈遵循后进先出（LIFO）原则，常见应用包括括号匹配和表达式求值；队列遵循先进先出（FIFO）原则，常用于树的层次遍历和操作系统中的资源调度。此外，文章还提及了双端队列和递归中的栈应用，以及栈和队列在表达式转换和计算中的作用。

摘要由CSDN通过智能技术生成

栈和队列

1.栈(Stack)的基本概念

后进先出(LIFO)
只允许在一端进行插入或删除操作的线性表
增(进栈)，删(出栈)，查(获取栈顶元素)
常考：根据进栈顺序，判断合法的出栈顺序(选择题)

数值最大的数字后面必然是降序

2.栈的顺序存储实现

2.1 顺序栈的定义

#define MaxSize 10	//定义栈中元素的最大个数
typedef struct{
   ElemType data[MaxSize];	//静态数组存放栈中元素
   int top;	//栈顶指针
} SqStack;

2.2 入栈操作

bool Push(SqStack &S,ElemType x){
	if(S.top == MaxSize - 1)	//栈满，报错
    	return false;
  //这两句等价 S.data[++S.top] = x;
  S.top = S.top + 1;	//指针先加一，移到下一个位置
  S.data[S.top] = x;	//新元素入栈
  
  return true;
}

2.3 出栈操作(获取类似)

bool Pop(SqStack &S,Elemtype &x){
		if(S.top == -1)
      return false;
  	//这两句等价 x = S.data[S.top--]
  	x = S.data[S.top]; //栈顶元素先出栈
  	S.top = S.top - 1; //指针减一
  
  	return true;
}

注意观察top指针位置，top指针是指向栈顶元素(top=0)还是指向栈顶元素后面的一个位置(初始top=-1)，上方实现为第二种

2.4 共享栈

#define MaxSize 10	//定义栈中元素的最大个数
typedef struct{
   ElemType data[MaxSize];	//静态数组存放栈中元素
   int top0;	//0号栈顶指针
   int top1； //1号栈顶指针
} SqStack;

void InitStack(ShStack){
  S.top0 = -1;
  s.top1 = MaxSize;
}

共享栈栈满的条件：top0 + 1 == top1

3. 栈的链式存储实现

链头 = 栈顶
链栈的定义和单链表没有区别

typedef struct Linknode{
	ElemType data;					//数据域
  struct Linknode *next;	//指针域
}*LiStack;

栈的链式存储操作与链表相同(推荐实现方式是不带头结点的实现方式)

4. 队列的基本概念

先进先出(FIFO)
入队，出队，读取队头元素，队空(队头=队尾)
只允许在一端进行插入，在另一端进行删除的线性表

4.1 队列的顺序实现

#define MaxSize 10
typedef struct{
 ElemType data[MaxSize];		//用静态数组存放队列元素
 int front,rear;	//队头指针和队尾指针
}SqQueue

4.2 循环队列入队

bool EnQueue(SqQueue &Q,ElemType x){
  //队尾指针的下一个位置是队头则证明循环队列满了
	if((Q.rear+1)%MaxSize == Q.front)	//队满则报错	 
		return false;	
	Q.data[Q.rear] = x;		//新元素插入队尾
	Q.rear = (Q.rear+1)%MaxSize;//队尾指针+1取模
	return true;
}

用模运算将线状的存储空间逻辑上变成了“环状“

4.3 循环队列出队

bool DeQueue(SqQueue &Q,ElemType &x){
  //判断队列是否为空，队头是否等于队尾
	if(Q.rear == Q.front)
		return false;	//队空则报错
	x = Q.data[Q.front];
	Q.front = (Q.front+1)%MaxSize;	//队头指针后移
	return true;
}

4.4 队列已满的判断

队列元素的个数=(rear+MaxSize-front)%MaxSize
当初始化是rear=front=0时：

队满：rear的下一个元素是front时

队空：rear == front

缺点：会浪费一个节点的空间
解决方案：
利用size的大小记录队中的元素个数，从而判断队满/空
利用tag，删除操作时tag=0，插入操作时tag=1

队满： front == rear && tag == 1

对空： front == rear && tag == 0

4.5 其它出题方法

队尾指针默认是指向队尾元素的下一个位置，队头指针指向队头

4.6 队列的链式实现

//链式队列的结点c
typedef struct LinkNode{		
	Elemtype data;
	struct LinkNode *next;
}LinkNode;

//链式队列
typedef struct{
  LinkNode *front,*rear;	//队列的队头和队尾指针
}LinkQueue;

4.7 链式入队(带头结点)

void EnQueue(LinkQueue &Q,Elemtype x){
	LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode))
  s->data = x;
  s->next = NULL;
  Q.rear->next = s;	//新节点插入到rear之后
  Q.rear = s;		//修改表尾指针
}

4.8 链式入队(不带头结点)

void EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode))
  s->data = x;
  s->next = NULL;
  //不带头结点的队列，第一个元素入队时需要特别处理
  if(Q.front == NULL){	//在空队列中插入第一个元素
  //修改队头队尾指针
  	Q.front = s;
  	Q.rear = s;
  }
  Q.rear->next = s;	//新节点插入到rear之后
  Q.rear = s;		//修改表尾指针
}

4.9 链式出队(带头结点)

bool DeQueue(LinkQueue &Q,ElemType &x){
	//如果是空队列，直接返回false
	if(Q.front == Q.rear)
			return false;
	LinkNode *p = Q.front->next;//带头结点的后面一个结点出队
	x = p->data;		//用变量x返回队头元素
	Q.front->next = p->next;	//修改头结点的next指针
  //如果删除的是队尾结点，则需修改rear指针
	if(Q.rear == p)
		Q.rear = Q.front;
	free(p);		//删除操作都需要释放指针	
	return true;
}

4.10 链式出队(不带头结点)

bool DeQueue(LinkQueue &Q,ElemType &x){
	//如果是空队列，直接返回false
	if(Q.front == Q.rear)
			return false;
	LinkNode *p = Q.front; //当前结点出队
	x = p->data;		//用变量x返回队头元素
	Q.front = p->next;	//修改该结点的next指针
  //如果删除的是队尾结点，则需修改指针
	if(Q.rear == p)
		Q.rear = NULL;
    Q.front = NULL;
	free(p);		//删除操作都需要释放指针	
	return true;
}

链式结构存储，需要注意带头结点和不带头结点版本

5. 双端队列

允许从两端插入删除的线性表
输入受限的双端队列，输出受限的双端队列
考点：输入序列1,2,3,4 判断输出序列是否合法

先按照栈的顺序判断，再从栈中不合法的找出满足双端队列的

6. 栈的应用

6.1 括号匹配问题

使用顺序栈实现(也可以使用链栈)
匹配失败：左括号单身，右括号单身，左右括号不匹配

bool bracketCheck(char str[],int length){
	SqStack S;
	InitStack(S);	 //初始化一个栈
	//遇见左括号存起来
	for(int i = 0; i<length ;i++){
			if(str[i]=='('||str[i]=='['||str=='{'){
					Push(S,str[i]); 	//如果是左括号则入栈
			}else{		//右括号
					if(StackEmpty(s))	//扫描到右括号，且当前栈空
						return false;
					char topElem；
					Pop(S,topElem);	//栈顶元素出栈,存值到topElem
					if(str[i]==')' && topElem!='(')
						return false;
					if(str[i]==']' && topElem!='[')
						return false;
					if(str[i]=='}' && topElem!='{')
						return false;
			}
	}
	return StackEmpty(S);	//检索完括号后，栈空说明匹配成功
}