队列之链式存储 C++代码实验

#include<iostream>
using namespace std;

#define DataType int

typedef class Node{             //队列链节点
    public:
    DataType data;
    Node *next;    
}Node;

typedef class queue{            //链式队列
    Node *front,*rear;
    int length;                      //节点计数
    public:
    queue();                           //构造函数
    void push(DataType push_data);     //进队
    DataType pop();                    //出队
    DataType getfront();               //第一个元素
    DataType getback();                //最后一个元素
    int size();                        //元素个数
    bool empty();                      //判断是否为空
}queue;

queue::queue()
{
    length = 0;
    //链式队列设立头节点在操作上会方便许多
    Node* node;
    node = (Node*)malloc(sizeof(Node));
    node->data = -1;
    node->next = NULL;
    front = node;                  
    rear = node;
}

void queue::push(DataType push_data)
{
    //创建新节点
    Node *node;
    node =(Node*)malloc(sizeof(Node));
    node->data = push_data;
    node->next = NULL;
    //将节点插入队尾
    rear->next = node;
    rear = node;
    length++;
    cout<<push_data<<" 入队."<<endl;
}

DataType queue::pop()
{
    if(length == 0) 
    {
        cout<<"出队错误：队列为空！"<<endl;
        return -1;
    }
    Node *node;
    node = front->next;
    DataType pop_data = node->data;
    front->next = node->next;
    free(node);
    length--;
    cout<<pop_data<<" 出队."<<endl;
    //队列尾元素被pop后rear需要手动回调到链头，否则rear变成野指针
    //其他元素pop时，rear不需要有任何变动，因为它始终指向链尾元素的地址
    if(length==0)
        rear = front;
    return pop_data;
}

DataType queue::getfront()
{
    if(length == 0)
    {
        cout<<"获取错误：队列为空！"<<endl;
        return -1;
    }
    DataType front_data = front->next->data;
    cout<<"队列首元素："<<front_data<<endl;
    return front_data;
}

DataType queue::getback()
{
    if(length == 0)
    {
        cout<<"获取错误：队列为空！"<<endl;
        return -1;
    }
    DataType back_data = rear->data;
    cout<<"队列尾元素："<<back_data<<endl;;
    return back_data;
}

bool queue::empty()
{
    if(length == 0)
    {
        cout<<"检查：队列为空！"<<endl;
        return true;
    }
    cout<<"检查：队列非空！"<<endl;
    return false;
}

int queue::size()
{
    cout<<"队列元素数为 "<<length<<endl;
    return length;
}

int main()
{
    queue q1;
    q1.push(1);
    q1.push(2);
    q1.push(3);
    q1.push(4);
    q1.getback();
    q1.getfront();
    q1.push(5);
    q1.push(6);
    q1.size();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.getback();
    q1.getfront();
    q1.empty();
    q1.size();
    q1.push(7);
    q1.push(8);
    q1.push(9);
    q1.push(10);
    q1.size();
    q1.getback();
    q1.getfront();
    q1.push(11);
    q1.push(12);
    q1.push(13);
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.pop();
    q1.push(14);
    q1.push(15);
    q1.push(16);
    q1.push(17);
    q1.push(18);
    q1.push(19);
    q1.empty();
}

运行结果：（虽然测试语句和顺序存储实验中一致，但链式队列不会有溢出问题，所以结果会不同）

1 入队.
2 入队.
3 入队.
4 入队.
队列尾元素：4
队列首元素：1
5 入队.
6 入队.
队列元素数为 6
1 出队.
2 出队.
3 出队.
4 出队.
5 出队.
6 出队.
出队错误：队列为空！
出队错误：队列为空！
获取错误：队列为空！
获取错误：队列为空！
检查：队列为空！
队列元素数为 0
7 入队.
8 入队.
9 入队.
10 入队.
队列元素数为 4
队列尾元素：10
队列首元素：7
11 入队.
12 入队.
13 入队.
7 出队.
8 出队.
9 出队.
10 出队.
11 出队.
12 出队.
13 出队.
14 入队.
15 入队.
16 入队.
17 入队.
18 入队.
19 入队.
检查：队列非空！

附：队列之顺序存储 C++代码实验