队列和栈

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表

每次在队尾插入一个元素是，rear增1；每次在队头删除一个元素时，first增1。随着插入和删除操作的进行，队列元素的个数不断变化，队列所占的存储空间也在为队列结构所分配的连续空间中移动。当front=rear时，队列中没有任何元素，称为空队列。当rear增加到指向分配的连续空间之外时，队列无法再插入新元素，但这时往往还有大量可用空间未被占用，这些空间是已经出队的队列元素曾经占用过得存储单元。

顺序队列中的溢出现象：
（1） “下溢”现象：当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。
（2）”真上溢”现象：当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。
（3）”假上溢”现象：由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为”假上溢”现象。

#include <iostream>
using namespace std;

struct Node
{
    Node(int data)
        :_data(data)
        ,_pNext(NULL)
    {}

    int _data;
    Node* _pNext;
};

struct Queue
{
    Queue()
        :_first(NULL)
        ,_rear(NULL)
        ,_size(0)
    {}
    Node* _first; //队头指针
    Node* _rear;  //队尾指针
    size_t _size; //元素个数
};

//入队操作
Queue* Push(Queue* q, int data)
{

    Node* pNode = new Node(data);

    if(q->_rear == NULL) // 空队列
    {
        q->_first = pNode;
        q->_rear = pNode;
    }
    else
    {
        q->_rear->_pNext = pNode;
        q->_rear = pNode; //尾指针后移
    }
    q->_size++;
    return q;
}

//出队操作
Queue* Pop(Queue* q)
{
    Node* pCur = NULL;
    if(q->_first == NULL)
        cout<<"It's a empty quque"<<endl;
    else
    {
        int tmp = q->_first->_data;
        pCur = q->_first;
        if(q->_first == q->_rear) //队列里只有一个元素
        {
            q->_first = NULL;
            q->_rear = NULL;
        }
        else
        {
            q->_first = q->_first->_pNext;
            free(pCur);
        }
        q->_size--;
        return q;
    }
}

int main()
{
    Queue q;
    Push(&q, 1);
    Push(&q, 2);
    Push(&q, 3);
    Push(&q, 4);
    Push(&q, 5);
    Push(&q, 6);
    Push(&q, 7);

    Pop(&q);
    Pop(&q);

    system("pause");
    return 0;
}

定义：栈是限定仅在表头进行插入和删除操作的线性表。要搞清楚这个概念，首先要明白”栈“原来的意思，如此才能把握本质。”栈“者,存储货物或供旅客住宿的地方,可引申为仓库、中转站，所以引入到计算机领域里，就是指数据暂时存储的地方，所以才有进栈、出栈的说法。

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。
栈可以用来在函数调用的时候存储断点，做递归时要用到栈！

1．进栈（PUSH）算法
①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）；
②置TOP=TOP+1（栈指针加1，指向进栈地址）；
③S(TOP)=X，结束（X为新进栈的元素）；

2．退栈（POP）算法
①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作②)；
②X=S(TOP)，（退栈后的元素赋给X）;

struct Node
{
    Node(int data)
        :_data(data)
        ,_pNext(NULL)
    {}

    int _data;
    Node* _pNext;
};

struct Stack
{
    Stack()
        :_below(NULL)
        ,_top(NULL)
        ,_size(0)
    {}

    Node* _below; //栈底
    Node* _top; //栈顶
    size_t _size; //元素个数
};

//入栈操作
Stack* Push(Stack* s, int data)
{
    Node* pNode = new Node(data);

    if(s->_below == NULL) //空栈
    {
        s->_below = pNode;
        s->_top = pNode;
    }
    else
    {
        s->_top->_pNext = pNode;
        s->_top = pNode; //更新栈顶
    }
    s->_size++;
    return s;
}

//入栈操作
Stack* Pop(Stack* s)
{
    Node* pCur = NULL;

    if(s->_below == NULL)
        cout<<"It's a empty stack"<<endl;
    else

    {
        int tmp = s->_below->_data;
        pCur = s->_below;

        if(s->_below == s->_top)
        {
            s->_below = NULL;
            s->_top = NULL;
        }
        else
        {
            while(pCur->_pNext != s->_top)
            {
                pCur = pCur->_pNext;
            }
            s->_top = pCur;
            s->_top->_pNext = NULL;
        }
        s->_size--;
        return s;
    }
}

int main()
{
    Stack s;
    Push(&s, 1);
    Push(&s, 2);
    Push(&s, 3);
    Push(&s, 4);
    Push(&s, 5);
    Push(&s, 6);
    Push(&s, 7);

    Pop(&s);
    Pop(&s);

    system("pause");
    return 0;
}