【数据结构和算法5】栈和队列

---

一、栈和队列的的定义和特点

1.栈

2.队列

二、案例引入

1.栈的应用案例

2.队列的应用案例

三.栈的表示和实现

1.栈的数据同线性表。元素具有相同的类型，相邻元素具有前驱和后继的关系。

1.顺序栈的表示和实现

两个指针相减是两个指针之间的差距，即差几个元素。（指向不同数组的指针是不能相减的）

#include <iostream>
using namespace std;
#include "windows.h"
#define MAXSIZE 100
typedef int SElemType

//顺序栈的存储结构
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;

//初始化
//当遇到 main 函数中的 return 语句时，C++ 程序将停止执行。但其他函数结束时，程序并不会停止。
//程序的控制将返回到函数调用之后的位置。然而，有时候会出现一些非常少见的情况，使得程序有必要在 main 以外的函数中终止。
//要实现这一点，可以使用 exit 函数。
//当调用 exit 函数时，无论是哪个函数包含了该调用，都将导致程序停止。
void InitStack(SqStack &S){
    S.base = new SElemType[MAXSIZE];
    if (!S.base) exit(EXIT_FAILURE);
    S.top = S.base;
    S.stacksize = MAXSIZE;
}

//判断顺序栈是否为空
bool StackEmpty(SqStack S){
    if (S.top == S.base)
    {
        return -1;
    }
    else
        return 0;
}
//求顺序栈的长度
int StackLength(SqStack S)
{
    return S.top - S.base;
}

//清空顺序栈
int ClearStack(SqStack &S)
{
    if(S.base)
        S.top = S.base;
    return 0;
}

//销毁顺序栈
int DestroyStack(SqStack &S)
{
    if (S.base)
    {
        delete S.base;
        S.stacksize = 0;
        S.base = S.top = NULL;
    }
    return 0;
}

//入栈
int Push(SqStack &S, SElemType e)
{
    if(S.top - S.base == S.stacksize) return -1;
    //*S.top ++= e;
    *S.top = e;
    S.top++;
    return 0;
}

//出栈
int Pop(SqStack &S, SElemType &e)
{
    if (S.top == S.base) return -1;
    //e = *--S.top;
    S.top--;
    e = *S.top;
    return 0;
}

2.链栈的表示和实现

//链栈的存储结构
typedef struct StackNode{
    SElemType data;
    struct StackNode * next;
}StackNode,*LinkStack;

//链栈的初始化
//链栈没有头结点
void InitLinkStack(LinkStack &S){
    S=NULL;
};

//链栈的入栈
int LinkPush(LinkStack &S, SElemType e){
    LinkStack p = new StackNode;
    p->data = e;
    p->next = S;
    S = p;
    return 0;
}

//链栈的出栈
int LinkPop(LinkStack &S, SElemType &e)
{
    if (S=NULL) return -1;
    e = S->data;
    LinkStack p = S;
    S = S->next;
    delete p;
    return 0;
}

//取栈顶元素
SElemType GetLinkTop(LinkStack S)
{
    if (S != NULL)
        return S->data;
}

四.栈和递归

五.队列的表示和实现

1.队列的循环顺序结构

//顺序队列的数据结构
typedef struct
{
    SElemType *base;  数组首元素的地址
    int front, rear;
}SQueue;
//初始化
void InitQueue(SQueue &Q)
{
    Q.base = new SElemType[MAXSIZE];
    if (!Q.base) exit(EXIT_FAILURE);
    Q.front = Q.rear = 0;
}

//求队列长度
int QueueLength(SQueue Q)
{
    cout << (Q.rear-Q.front) << endl;
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

//入队
void EnQueue(SQueue &Q, SElemType e)
{
    if((Q.rear+1)%MAXSIZE == Q.front) return;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear+1)%MAXSIZE;
}

//出队
void DEQueue(SQueue &Q, SElemType &e)
{
    if(Q.rear == Q.front) return;
    e = Q.base[Q.front];
    Q.front = (Q.front+1)%MAXSIZE;
}

2.队列的链式存储结构

//链队列的初始化
void InitLinkQueue(LinkQueue &Q)
{
    Q.front = new QNode;
    if (!Q.front) exit(EXIT_FAILURE);
    Q.front->data =0;
    Q.front->next = NULL;
    Q.rear = Q.front;
}

//链队的销毁
//从头结点开始，依次释放所有的结点
void DestroyLinkQueue(LinkQueue &Q)
{
    while (Q.front)
    {
        QueuePtr p = Q.front->next; //用Q.rear代替p也可以
        delete Q.front;
        Q.front = p;
    }
}

//链队列的入队
void EnListQueue(LinkQueue &Q, SElemType e)
{
    QueuePtr p = new QNode;
    if (!p) exit(EXIT_FAILURE);
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    cout << Q.rear->data << endl;
}

//链队列出队
void DeLinkQueue(LinkQueue &Q, SElemType &e)
{
    if (Q.front == Q.rear) return;
    QueuePtr p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;

    if (Q.rear == p) Q.rear = Q.front;
    delete p;
}

int main() {
    SetConsoleOutputCP(CP_UTF8);
    LinkQueue Q;
    SElemType e = 2;
    InitLinkQueue(Q);
    cout << Q.front->data << endl;

    EnListQueue(Q,e);
    cout << Q.rear->data << endl;

    return 0;
}