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

Posted 2020-11-01 leezheng

 题目：

　　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

 

 

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <algorithm>
  4 #include <vector>
  5 #include <string>
  6 using namespace std;
  7 
  8 class node_buffer
  9 {
 10 public:
 11     // 构造函数
 12     // 参数: max_size 指定缓冲的最大节点数
 13     node_buffer(int max_size);
 14 
 15     // 析构函数
 16     ~node_buffer();
 17 
 18     // 从队尾插入一个数据节点
 19     // 参数：i 待插入节点
 20     // 返回值：true 插入成功
 21     //         false 插入失败，表示数据节点个数达到最大值
 22     bool push_back(int i);
 23 
 24     // 从队首移除一个数据节点
 25     // 返回值：true 移除成功
 26     //         false 移除失败，表示数据节点个数为0
 27     bool pop_front();
 28 
 29     // 获取队首节点值，不移除数据
 30     int front();
 31 
 32     // 获取队尾节点值，不移除数据
 33     int back();
 34 
 35     // 获取数据节点数量
 36     // 返回值：数据节点数量
 37     int size();
 38 private:
 39     int* m_queue;
 40     int  m_max_size;
 41     int  m_front;
 42     int  m_back;
 43     int  m_size;
 44 };
 45 
 46 node_buffer::node_buffer(int max_size)
 47 {
 48     m_max_size = max_size;
 49     m_queue = new int[m_max_size];
 50     m_size = 0;
 51 }
 52 node_buffer::~node_buffer()
 53 {
 54 }
 55 bool node_buffer::push_back(int i)
 56 {
 57     if (m_size == 0)
 58     {
 59         *(m_queue + m_size) = i;
 60         m_size++;
 61         m_front = *m_queue;
 62         m_back = *m_queue;
 63         return true;
 64     }
 65     else if (m_size < m_max_size )
 66     {
 67         m_back = i;
 68         *(m_queue + m_size) = i;
 69         m_size++;
 70         return true;
 71     }
 72     else
 73         return false;
 74 }
 75 
 76 bool node_buffer::pop_front()
 77 {
 78     if (m_size > 0)
 79     {
 80         
 81         m_size--;
 82         m_queue++;
 83         m_front = *m_queue;
 84         return true;
 85     }
 86     else
 87         return false;
 88 }
 89 
 90 int node_buffer::front()
 91 {
 92     return m_front;
 93 }
 94 
 95 int node_buffer::back()
 96 {
 97     return m_back;
 98 }
 99 
100 int node_buffer::size()
101 {
102     return m_size;
103 }
104 
105 int main()
106 {
107     int num;
108     scanf("%d",&num);    
109     while (num--)
110     {
111         int max_size;
112         scanf("%d",&max_size);
113         node_buffer nb(max_size);
114         
115         int push_num;
116         scanf("%d",&push_num);
117 
118         vector<int> data(push_num);
119 
120         for (int i = 0; i < push_num; i++)
121         {
122             scanf("%d",&data[i]);
123         }
124 
125         if (push_num > max_size)
126         {
127             push_num = max_size;
128         }
129 
130         data.resize(push_num);
131 
132         for (int i = 0; i < push_num; i++)
133         {
134             nb.push_back(data[i]);
135         }
136 
137         int pop_num;
138         scanf("%d",&pop_num);
139 
140         if (pop_num > nb.size())
141         {
142             pop_num = nb.size();
143         }
144 
145         for (int i = 0; i < pop_num; i++)
146         {
147             nb.pop_front();
148         }
149 
150         int length = nb.size();
151         for (int i = 0; i < length; i++)
152         {
153             printf("%d ",nb.front());
154             //cout << nb.front() << " ";
155             nb.pop_front();
156         }
157         printf("\n");
158     }
159 
160     return 0;
161 }