数据结构第三章栈和队列

3.1.1栈的定义和特点

          栈的插入和删除在栈顶进行操作，遵循后进先出的规则。

3.1.2队列的定义和特点

        对队列的操作符合在一端插入在一端删除，遵循先进先出的特点。

3.2案列的引入

符合栈的：数制的转换，括号的匹配，表达式的求值。

队列的：舞伴问题。

3.3栈的表示和操作的实现

3.3.1栈的类型定义

ADT Stack{
    数据对象：D：{ai|ai∈elemset,i=1,2..n,n>=0}
    数据关系：R={<ai-1,ai>|ai-1,ai∈D，i=2,....,n}
    基本操作：
    InitStack(&S)
        操作结果：构造一个空栈
    DestoryStack(&S)
       初始条件：栈已存在
        操作结果：栈被销毁
    ClearStack(&S)
        初始条件：栈已存在
        操作结果：栈被清空
    StackEmpty(S)
        初始条件：栈已存在
        操作结果：栈为空返回true,否则false
    StackTraverse(S)
        初始条件：栈已存在且不为空
        操作结果：从栈底到栈顶依次进行访问

重点操作记忆：

返回栈顶，插入，删除。

GetTop(S)
    初始条件：栈已存在且非空
    操作结果：返回栈顶元素，不修改栈顶指针。
Push(&S,e)
    初始条件：栈存在且非空。
    操作结果：插入元素e为新的栈顶元素。
Pop(&S,&e)
    初始条件：栈存在且非空
    操作结果：删除栈顶元素，并用e返回其值。
}ADT Stack

3.3.2顺序栈的表示和实现

        顺序栈也是使用连续的存储空间，从栈底到栈顶依次存放数据。

顺序栈的存储结构

#define MAXSIZE 100 //顺序栈的初始空间分配量
typedef struct
{
    SElemType *base;
    SelemType *top;
    int stacksize;
}sqStack
初始化完成后base指向栈底，当base=null栈结构不存在，
当top==base=null栈空，栈非空时栈顶指向元素的上一个位置。

1.顺序栈的初始化

Status InitStack(SqStack &S){
    S.base=new SElemType[MAXSIZE];
    if(!base) exit (OVERFLOW);
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}
//分配一个maxsize容量的空间，判断是否申请到了空间。
将top初始化base空栈。

2.销毁顺序栈

Status DestroyStack(sqStack &S){
 if(S.base){
    delete S.base;
    S.stacksizse=0;
    S.base=S.top=NULL;
}
    return OK;
}

2.入栈

Status Push(SqStack &S,SElemType e)
{
    if(S.top-S.base==S.stacksize)
    return ERROR;
    * S.top++=e;
    return ok;
}
//判断是否栈满，元素压入栈顶，之后栈顶加1。

3.出栈

Status Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)
    return ERROR;
    e=*--S.top;
    return ok;
}
//判断栈是否为空防止下溢，获取栈顶元素e,栈顶元素减一。

4.取栈顶的元素

SElemType GetTop(SqStack S)
{
    if(S.top!=S.base)
        return *(S.top-1);
}

3.3.3链栈的表示和实现

只在链表表头进行操作。

链栈的存储结构

typedef struct StackNode{
    SElemType data;
    struct StackNode *next;
} StackNode,*LinkList;
LinkStack S;
//链表的头指针就是栈顶，不需头结点，插入和删除只在栈顶进行操作。

1.初始化

void InitStack(LinkStack &S){
    S=NULL;
    return OK;
}

2.入栈

Status Push(LinkStack &S,SElemType e){
    p=new StackNode;
    p->data=e;
    p->next=S;
    S=p
    return ok;
}
//生成一个新的结点，把新结点的数据域置为e,修改栈顶指针。

3.出栈

Status Pop(LinkStack &S,SElemType &e){
    if(S==NULL) return ERROR;
    e=S->data;
    p=S;
    S=S->next;
    delete p;
    return OK;
}
//判断栈是否为空，将栈顶元素赋值给e,用p保存栈顶元素，修改栈顶指针。

3.4栈与递归

间接直接的调用自己。

策略有：分治法等

3.5队列的表示和操作的实现

删除在头部，添加在尾部进行。

类型定义

ADT Queue{
    数据对象：
    数据关系：
    基本操作：
InitQueue(&Q)
    操作结果：构造一个空队列Q。
EnQueue(&Q,e)
    初始条件：队列已存在
    操作结果：插入元素e为新的队列
DeQueue(&Q,&e)
    初始条件：队列已存在
    操作结果：删除Q的队列元素，并用e返回其值。
}ADT

队列的顺序存储结构

#define MAXQSIZE 100  
Typedef struct{
    QElemType *base;
    int font;
    int rear;
} SqQueue;
//定义最大队列长度，初始化分配动态空间，头指针，尾指针。
空队列时font=rear=0,入队base[rear]=x;rear++;,出队x=base[front];front++;空队标志：front==rear

3.5.2解决假溢出的问题

插入元素：Q.base[Q.rear]=x;Q.rear=(Q.rear+1)%MAXQSIZE;

删除元素：x=Q.base[s.front];Q.front=(Q.front+1)%MAXQSIZE;

3.5.2少用一个元素空间

判断是队空还是队满

队空：front==rear

队满：尾指针再加一，就是与头指针重合 则（rear+1）%MAXQSIZE==front;

1.循环队列的操作-队列的初始化

Status InitQueue(SqQueue &Q){
    Q.base=new QElemType[MAXQSIZE]
    IF(!Q.base) exit(OVERFLOW);
    Q.front==Q.rear=0;
    return ok;
}

2.求队列的长度

int QueueLength(SqQueue Q){

        return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;

}

3.循环队列的入队

Status EnQueue(SqQueue &Q,QElemType e){
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
}
//判断是否队满，新元素加入队尾，队尾指针加1

4.循环队列的出队

Status DeQueue(SqQueue &Q,QElemType &e){
    if(Q.front==Q.rear) return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return OK;
}
//判断队是否为空，保存队头元素，队头元素指针加一

3.5.3链队-队列的链式表示和实现

用于无法估计队列的长度，采用链队列

链队列的类型定义

#define MAXQSIZE 100
typedef struct Qnode{
    QElemType data;
    struct Qnode *next;
}QNode,*QuenePtr

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

1.初始化

Status InitQueue(LinkQueue &Q){
    Q.front=Q.rear=new QNode;
    Q.front->next=NULL;
    return ok;
}
//生成新结点做头结点，队头和队尾都指向此结点，头结点指针域置空。

2.销毁链队列

从头结点开始依次释放所有结点

Status DestroyQueue(LinkQueue &Q){
    while(Q.front){
    p=Q.front->next;free(Q.front);Q.front=p;
    }
    return ok;
}

3.入队

Status EnQueue(LinkQueue &Q,QElemType e){

        p=(QueuePTtr)malloc(sizeof(QNode));

        if(!p)exit(OVERFLOW);

        p->data=e;p->next=NULL;  

        Q.rear->next=p;     

        Q.rear=p;

        return ok;

}
//为入队元素分配空间，用指针p指向，将新结点的数据域置为e,将新结点插入队尾，修改尾指针p

4.出队

Status DeQueue(LinkQueue &Q,QElemType &e){
    if(Q.front==Q.rear) return ERROR;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p) Q.rear=Q.front;
    delete p;
    return OK;
}
//判断队列是否为空，临时保存队头元素的空间，以备释放，修改头结点的指针域，指向下一个结点，判断出去的是否为最后一个元素，是的话将队尾指针重新赋值，指向头结点。释放原队头元素。