栈和队列

栈和队列

• 栈的逻辑结构（只能在一端（栈顶）进行入栈和压栈操作的线性表）
• 栈的存储结构
  1、顺序结构
  2、链式结构
• 栈的基本操作
• 队列的逻辑结构
• 队列的存储结构
  1、顺序结构
  2、链式结构
• 队列的基本操作
• 栈和队列的应用
  一、栈的存储结构

抽象数据类型
typedef struct {
	int data[Maxsize];
	int top;
}SqStack;(静态存储)


typedef struct Node{
	int *data;
	int top;
}SqStack;(动态存储)

二、顺序栈的基本操作

初始化
void InitStack(SqStack &Stack)
{
	Stack.top=-1;
}

判空
int isEmpty(SqStack Stack)
{
	if(Stack.top==-1)return true;
	else return false;
}

压栈
int Push(SqStack &Stack,int x)
{
	if(Stack.top=Maxsize-1)return false;
	Stack.data[++Stack.top]=x;
	return true;
}

出栈
int Pop(SqStack &Stack ,int &x)
{
	if(SqStack.top==-1)return false;
	x=Stack.data[Stack.top++];
	return true;
}

读栈顶元素
int Gettop(SqStack Stack,int &x)
{
	if(SqStack.top==-1)return false;
	x=Stack.top[Stack.top];
}

共享栈

链栈
typedef struct StackNode{
	int data;
	struct StackNode *next;
}StackNode,*LinkStack;

三、循环队列（讲队列再逻辑上想象成环）
法一：牺牲一个存储单元
队空:Q.front==Q.rear;
队满:(Q.rear+1)%Maxsize ==Q.front;
队列元素数：(Q.rear-Q.front+Maxsize)%Maxsize ；

法二：增加一个变量 Q.size
队空：Q.size = =0;
队满：Q.size= =Maxsize;
队列元素数：(Q.rear-Q.front+Maxsize)%Maxsize ；

法三：增设tag变量，记录最后一次操作是删除还是插入
队空：:Q.front= =Q.rear&&tag= =0
队满：:Q.front= =Q.rear&&tag= =1
队列元素数：(Q.rear-Q.front+Maxsize)%Maxsize ；

初始化队列
void InitQueue(SqQueue &Q)
{
	Q.front=Q.rear=0;
}

队判空
int Queue(SqQueue Q)
{
	if(Q.front==Q.rear)return true;
	else return false;
}

入队
int EnQueue(SqQueue &Q,int x )
{
	if((Q.rear+1)%Maxsize==Q.front)return false;
	else{
		Q.data[Q.rear]=x;
		Q.rear=(Q.rear+1)Maxsize;
		return true;
}

出队
int OutQueue(SqQueue &Q,int &x)
{
	if(Q.front==Q.rear)return false;
	else{
		x=Q.data[Q.front];
		Q.front=(Q.front+1)%Maxsize;
		return true;
	}

}

四、链队

typedef struct QNode{
	int data;
	struct QNode *next;
}QNode,*linkQueue;


typedef struct {
	linkQueue rear;
	linkQueue front;
}LinkQueue;

初始化链队
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=(linkQueue)malloc(sizeof(QNode));
	Q.front=NULL;
}

判空
int Isempty(LinkQueue Q)
{
	if(Q.front==Q.rear)return true;
	else  return false;
}

入队
void EnQueue(LinkQueue &Q,int x)
{
	QNode*s=(linkQueue)malloc(sizeof(QNode));
	s->data=x;
	s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
}

出队
int DeQueue(LinkQueue &Q,int &x)
{
	if(Q.front==Q.rear) return false;
	p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(p==Q.rear)Q.rear=Q.front;
		free(p);
	return true;
}

五、双端队列及受限的双端队列（会考较为简单的选择填空题，略过）

六、栈的应用

• 括号匹配
• 进制转换
• 表达式求值
• 递归
  七、队列的应用
• 计算机系统的应用
• 层次遍历