数据结构与算法--栈和队列

03 栈和队列

3.1 栈的逻辑结构

栈只能在表尾插入或删除元素，也就是 后进先出。

3.2 栈的存储结构

3.2.1 顺序栈

也就是用一组 地址连续 的存储单元存放栈中元素。

（1）栈的动态分配顺序存储结构

#define STACK_INIT_SIZE 100          // 初始容量
#define STACKINCREAMENT  10          // 增量

typedef int SElemType

typedef struct
{
    SElemType *base;            // 栈底指针
    SElemType *top;             // 栈顶指针
    int stacksize;              // 当前存储容量
}SqStack;         

注意：SqStack 就是一整个栈，而不是结点。

（2）构造一个空顺序栈

Status InitStack(SqStack &S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if(!S.base)
        exit(OVERFLOW);
    
    S.base = S.top;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

（3）取栈顶元素

Status GetTop(SqStack S, ElemType &e)
{
    if(S.base == S.top)       // 判断栈是否为空
        return ERROR；
    e = *(S.top-1);         // 栈顶指针减一
    return OK;
}

（4）入栈

Status Push(SqStack &s, SElemType e)
{
    if(S.top - S.base >= S.stacksize)      // 若栈满，则追加空间
        S.base = (SElemType*)realloc(S.base, (S.stacksize+STACKINCREAMENT)*sizeof(SElemType));    
    if(!S.base)
        exit (OVERFLOW);
    
    S.top = S.base + S.stacksize;
    S.stacksize += STACKINCREAMENT;
    
    *(S.top++) = e;       // 入栈
    return OK;
}

（6）出栈

Status Pop(SqStack &S, SElemType &e)
{
    if(S.base == S.top)
        return ERROR;
    e = *(--S.top);
    return OK;
}

3.2.2 链栈

链栈通常不需要头结点。

typedef struct Snode     // 定义链栈结点
{
    SElemType data;          // 数据域
    struct Snode *link;      // 指针域 
}LinkStack;

3.3 栈的应用

3.3.1 函数嵌套调用

3.3.2 汉诺塔问题

3.4 队列的逻辑结构

（1）队列：限定只能在表的一端进行插入，在表的另一端进行删除的线性表。

队头（front）：允许删除的一端

队尾（rear）：允许插入的一端

（2）特殊队列：双端队列、超队列

3.5 队列的存储结构

3.5.1 链队列

（1）定义：每个结点包括数据域和指针域

// 定义结点
typedef struct Qnode
{
    QElemtype deta;        // 数据域
    struct Qnode *link;    // 指针域
}Qnode, *QueuePtr;

// 定义链队列
typedef struct 
{
    QueuePtr front;          // 头指针
    QueuePtr rear;           // 尾指针
}LinkQueue;

（2）构造空队列：初始时，头指针和尾指针都指向头结点

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(Qnode));
    if(!Q.front)      // 判断是否申请成功
        exit(OVERFLOW)
    Q.front->link = NULL;     // 设置头结点指针域
    return OK;
}

复杂度：T(n) = O(1)

（3）入队：在队尾添加元素

Status EnQueue(LinkQueue &Q, QElemType e)
{
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(Qnode));
    if(!p)
        exit(OVERFLOW);
    p->data = e;
    p->link = NULL;
    Q.rear->link = p;
    Q.rear = p;
    return OK;
}

复杂度：T(n) = O(1)

（4）出队：删除队首元素（注意：头指针一直指向头结点，而不是第一个结点）

Status DeQueue(LinkQueue &Q, QElemType e)
{
    QueuePtr p;
    if(Q.front == Q.rear)
        return ERROR;             // 判断是否为空
    p = Q.front->link;        // 指向第一个结点
    e = p->data;
    Q.front->link = p->link;
    if(Q.rear == p)
        Q.rear = Q.front;       // 出队结点为最后一个结点，此时队空
    free(p);
    return OK;
}

复杂度：T(n) = O(1)

3.5.2 顺序队列

顺序队列：即顺序存储的队列

（1）真溢出和假溢出

• 真溢出：

Q.front == 0 && Q.rear == Q.MAXSIZE; 

• 假溢出

Q.front != 0 && Q.rear == Q.MAXSIZE; 

（2）针对假溢出，可以采用循环队列，即队列首尾相接

1）循环队列入队

Q.base[Q.rear] = e;                   // 赋值
Q.rear = (Q.rear + 1) % MAXSIZE;      // 队尾指针后移

2）循环队列出队

e = Q.base[Q.front];
Q.front = (Q.front + 1) % MAXSIZE;       // 队首指针后移

3）那么，会出现一个问题，当 Q.front == Q.rear 时，到底是队空还是队满呢，于是，我们采用牺牲一个存储空间的方法来加以区分，

• 队空：Q.front == Q.rear

• 队满：Q.front == (Q.rear + 1) % MAXSIZE

（3）构造空循环队列

# define MAXSIZE 100

typedef struct 
{
    QElemType *base;     // 基址
    int front;
    int rear;           // 可以看做是数组下标
}SqQueue;

Status InitQueue(SqQueue &Q)
{
    Q.base = (QElemType*)malloc(MAXSIZE * sizeof(QElemType));
    if(!Q.base)
        exit(OVERFLOW);
    Q.front = Q.rear = 0;
    return OK;
}

（4）求循环队列中的元素个数

int QueueLength(SqQueue Q)
{
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

（6）循环队列入队

Status EnQueue(SqQueue &Q, QElemType e)
{
    if(Q.front == (Q.rear+1) % MAXSIZE)     // 判断是否队满
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    retur OK;
}

（7）循环队列出队

Status EnQueue(SqQueue &Q, QElemType &e)
{
    if(Q.rear == Q.front)
        return ERROR;            // 判断是否队空
    e = Q.base[Q.front];
    Q.front = (Q.front +1 ) % MAXSIZE;
    return OK;
}

3.6 队列的应用