2018大华软件大赛模拟赛第1题 （node_buffer定义了一个用于存储int型数据的缓冲器，请实现其声明的所有成员方法）

 题目：

　　node_buffer定义了一个用于存储int型数据的缓冲器，请实现其声明的所有成员方法，并满足如下要求：
　　1.除非调用pop_front，否则push_back成功的数据节点不可移除；
　　2.不可添加给定之外的数据成员和成员方法；

输入：

　　输入的第一行指定用例数量T；
　　用例的第二行输入指定插入的节点数量M；
　　用例的第三行输入指定插入的节点数值，使用空格隔开；
　　用例的第四行输入指定移除的节点数量N；

 输出：node_buffer中剩余的节点数据值，使用空格隔开；

class node_buffer
{
public:
 // 构造函数
 // 参数: max_size 指定缓冲的最大节点数
 node_buffer(int max_size);
 
 // 析构函数
 ~node_buffer();
 
 // 从队尾插入一个数据节点
 // 参数：i 待插入节点
 // 返回值：true 插入成功
 //         false 插入失败，表示数据节点个数达到最大值
 bool push_back(int i);
 
 // 从队首移除一个数据节点
 // 返回值：true 移除成功
 //         false 移除失败，表示数据节点个数为0
 bool pop_front();
 
 // 获取队首节点值，不移除数据
 int front();
 
 // 获取队尾节点值，不移除数据
 int back();
 
 // 获取数据节点数量
 // 返回值：数据节点数量
 int size();
private:
 int* m_queue;
 int  m_max_size;
 int  m_front;
 int  m_back;
 int  m_size;
};

Input:
1
8
9
1 2 3 4 5 6 7 8 9
4

Output:
5 6 7 8

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

class node_buffer
{
public:
    // 构造函数
    // 参数: max_size 指定缓冲的最大节点数
    node_buffer(int max_size);

    // 析构函数
    ~node_buffer();

    // 从队尾插入一个数据节点
    // 参数：i 待插入节点
    // 返回值：true 插入成功
    //         false 插入失败，表示数据节点个数达到最大值
    bool push_back(int i);

    // 从队首移除一个数据节点
    // 返回值：true 移除成功
    //         false 移除失败，表示数据节点个数为0
    bool pop_front();

    // 获取队首节点值，不移除数据
    int front();

    // 获取队尾节点值，不移除数据
    int back();

    // 获取数据节点数量
    // 返回值：数据节点数量
    int size();
private:
    int* m_queue;
    int  m_max_size;
    int  m_front;
    int  m_back;
    int  m_size;
};

node_buffer::node_buffer(int max_size)
{
    m_max_size = max_size;
    m_queue = new int[m_max_size];
    m_size = 0;
}
node_buffer::~node_buffer()
{
}
bool node_buffer::push_back(int i)
{
    if (m_size == 0)
    {
        *(m_queue + m_size) = i;
        m_size++;
        m_front = *m_queue;
        m_back = *m_queue;
        return true;
    }
    else if (m_size < m_max_size )
    {
        m_back = i;
        *(m_queue + m_size) = i;
        m_size++;
        return true;
    }
    else
        return false;
}

bool node_buffer::pop_front()
{
    if (m_size > 0)
    {
        
        m_size--;
        m_queue++;
        m_front = *m_queue;
        return true;
    }
    else
        return false;
}

int node_buffer::front()
{
    return m_front;
}

int node_buffer::back()
{
    return m_back;
}

int node_buffer::size()
{
    return m_size;
}

int main()
{
    int num;
    scanf("%d",&num);    
    while (num--)
    {
        int max_size;
        scanf("%d",&max_size);
        node_buffer nb(max_size);
        
        int push_num;
        scanf("%d",&push_num);

        vector<int> data(push_num);

        for (int i = 0; i < push_num; i++)
        {
            scanf("%d",&data[i]);
        }

        if (push_num > max_size)
        {
            push_num = max_size;
        }

        data.resize(push_num);

        for (int i = 0; i < push_num; i++)
        {
            nb.push_back(data[i]);
        }

        int pop_num;
        scanf("%d",&pop_num);

        if (pop_num > nb.size())
        {
            pop_num = nb.size();
        }

        for (int i = 0; i < pop_num; i++)
        {
            nb.pop_front();
        }

        int length = nb.size();
        for (int i = 0; i < length; i++)
        {
            printf("%d ",nb.front());
            //cout << nb.front() << " ";
            nb.pop_front();
        }
        printf("
");
    }

    return 0;
}