2019数据结构考研(三)------栈和队列

栈和队列

知识架构

栈

栈的基本概念

栈的定义:栈是一种只允许在一端进行插入或者删除的线性表(后进先出的线性表)
栈顶:栈中允许插入和删除的一端
栈底:固定的
空栈

栈的顺序存储结构

栈的顺序表示

#define MaxSize 50
typedef struct {
    ElemType data[MaxSize];
    int top;//栈顶指针 
}SqStack;

顺序栈基本操作的实现

• 栈的初始化

void InitStack(SqStack &S){
    S.top=-1;//初始化栈顶元素  
}

• 判断栈空

bool StackEmpty(SqStack s){
    if(s.top==-1)
    return true;//栈为空,返回true 
    else
    return false;
} 

• 入栈操作

bool Push(SqStack &s,ElemType x){
    if(s.top==MaxSize-1)//判断栈满
    return false;
    else
    s.data[++s.top]=x;//栈顶指针先加一,再入栈 
    return true; 
} 

• 出栈操作

bool Pop(SqStack &s,ElemType x){
    if(s.top==-1)//判断栈空 
    return false;
    else
    x=s.data[s.top--];//先出栈,指针减一 
    return true; 
} 

• 读栈顶元素

bool GetTop(SqStack s,Elemtype x){
    if(s.top==-1)
    return false;//栈空,报错
    else
    x=s.data[top];//x记录栈顶元素 
    return true; 
}

在栈顶指针指向栈顶元素时
在入栈的时候,指针先加一,然后数据入栈
在出栈的时候,数据先出栈,然后指针减一

栈的链式存储结构

栈的链式存储类型

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

习题

队列

队列的基本概念

• 队列:队列是指只在一端进行删除在一端进行插入的受限操作的线性表
• 队头:只允许删除的一端,又称为队首
• 队尾:允许插入的一端

队列的顺序存储结构

队列的顺序存储类型可以描述为

typedef struct{
    ElemType data[MaxSize];
    int front,rear;//队尾和队首指针 
}SqQuence;

为了解决假溢出的问题,提出来循环队列的概念

循环队列的基本操作

• 队列初始化

void InitQuence(SqQuence &q){
    q.rear=q.front=0;//初始化队首和队尾指针 
} 

• 判空

bool isEmpty(SqQuence q){
    if(q.rear==q.front)//队列为空的条件 
    return true;
    else
    return false;
}

• 入队

bool enQuence(SqQuence &q,ElemType x){
    if((q.rear+1)%MaxSize==q.front)//队满 
    return false;
    q.data[rear]=x;
    rear=(rear+1)%MaxSize; //队尾指针加一取模 
    return true;
} 

• 出队

bool DeQuence(SqQuence &q,ElemType x){
    if(q.rear==q.front)//队空 
    return false;
    x=q.data[front];
    front=(front+1)%MaxSize; //队首指针加一取模 
    return true;
}

队列的链式存储结构

队列的链式表示称为链队列:是指同时带有队首指针和队尾指针的单链表.头指针指向队头结点,尾指针指向队尾结点

链队列的基本操作

• 初始化链队列

void InitQuence(LinkNode &q){
    q.front=q.rear=(LinkNode*)malloc(sizeof(LinkNode));//建立头结点
    q.front->next=null;//初始为空 
}

• 判队空

bool IsEmpty(LinkNode q){
    if(q.front==q.rear)
    return true;
    else 
    return false;
} 

• 入队

void EnQuence(LinkNode &q,ElemType x){
    s=(LinkNode*)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=null;
    q.rear->next=s;
    q.rear=s;
}

• 出队

 - 出队
bool DeQuence(LinkQuence &q,ElemType 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;
}