STL03——手写一个简单版本的Deque

手写一个简单版本的Deque

题目描述

设计一个名为 Deque 的 Deque 类，该类具有以下功能和特性：

1、基础成员函数

• 构造函数：初始化 Deque 实例
• 析构函数：清理资源，确保无内存泄露

2、核心功能

• 在 Deque 末尾添加元素
• 在 Deque 开头添加元素
• 删除 Deque 末尾的元素
• 删除 Deque 开头的元素
• 获取 Deque 中节点的数量
• 删除 Deque 中所有的元素

3、迭代与遍历

• 打印 Deque 中的元素

4、辅助功能

• 重载[]运算符以对 Deque 进行索引访问

输入描述

题目的包含多行输入，第一行为正整数 N, 代表后续有 N 行命令序列。

接下来 N 行，每行包含一个命令，命令格式为 [operation] [parameters] ，具体命令如下：

**
**

push_back 命令：

• 格式：push_back [value]
• 功能：在双端队列末尾添加值为 value 的元素

push_front 命令：

• 格式：push_front [value]
• 功能：在双端队列开头添加值为 value 的元素

pop_back 命令：

• 格式：pop_back
• 功能：删除双端队列末尾的元素

pop_front 命令：

• 格式：pop_front
• 功能：删除双端队列开头的元素

clear 命令：

• 格式：clear
• 功能：清空双端队列

size 命令：

• 格式：size
• 功能：获取双端队列中节点的数量

get 命令：

• 格式：get [index]
• 功能：获取双端队列中索引为 index 的节点的值

print 命令：

• 格式：print
• 功能：打印双端队列中的元素

输出描述

输出为每行命令执行后的结果，具体输出格式如下：

push_back 命令：无输出

push_front 命令：无输出

pop_back 命令：无输出

pop_font 命令：无输出

clear 命令：无输出

size 命令：输出一个整数，独占一行，代表 Deque 中元素的数量

get 命令：输出双端队列中索引为 index 的节点的值

print 命令：输出双端队列中的元素

#include <iostream>
#include <stdexcept>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;

template<typename T>
class Deque
{
private:
	T* elements;
	size_t capacity;
	size_t size;
	size_t frontIndex;
	size_t backIndex;
public:
	Deque():elements(NULL),capacity(0),size(0),frontIndex(0),backIndex(0)
	{}

	~Deque()
	{
		clear();
		delete[] elements;
	}

	void push_front(const T& value)
	{
		if (size == capacity)
			resize();
		frontIndex = (frontIndex - 1 + capacity) % capacity;//注意这里的形式
			elements[frontIndex] = value;
			size++;
	}

	void push_back(const T& value)
	{
		if (size == capacity)
			resize();
		//注意这里的顺序变了，是先插入再变位置，
		//backIndex指向的是末尾元素的下一个位置，所以与frontIndex的操作不同
		elements[backIndex] = value;
		backIndex = (backIndex + 1) % capacity;
		size++;
	}

	void pop_front()
	{
		if (size == 0)
			throw out_of_range("Deque is empty");
		//在逻辑上删除了
		frontIndex = (frontIndex + 1) % capacity;
		size--;
	}

	void pop_back()
	{
		if (size == 0)
			throw out_of_range("Deque is empty");
		backIndex = (backIndex - 1 + capacity) % capacity;
		size--;
	}

	T& operator[](size_t index)
	{
		if (index < 0 || index >= size)
			throw out_of_range("index out of range");
		//逻辑上的下标和实际上的下标之间进行转换
		return elements[(frontIndex + index) % capacity];//别忘了取余
	}

	size_t getSize() const
	{
		return size;
	}

	void clear()
	{
		while (size>0)
		{
			pop_front();
		}
	}

	void printElements() const
	{
		//注意物理下标与逻辑下标的区别
		size_t index = frontIndex;
		for (size_t i = 0; i < size; i++)
		{
			cout << elements[index] << " ";
			index = (index + 1) % capacity;
		}
		cout << endl;
	}
private:
	void resize()
	{
		size_t newCapacity = (capacity == 0) ? 1 : 2 * capacity;
		T* newElements = new T[newCapacity];//括号内肯定是容量
		size_t index = frontIndex;
		//这里是不能用copy的,因为copy用的是物理地址，而我们这里是逻辑地址的frontIndex
		for (size_t i = 0; i < size; i++)
		{
			newElements[i] = elements[index];
			index = (index + 1) % capacity;
		}
		delete[] elements;
		elements = newElements;//要搞清楚谁才是替代品
		capacity = newCapacity;
		frontIndex = 0;
		backIndex = size;//backIndex在末尾元素的下一个位置
	}
};

int main() {
	// 创建一个 Deque 对象
	Deque<int> myDeque;

	int N;
	std::cin >> N;
	// 读走回车
	getchar();
	std::string line;
	// 接收命令
	for (int i = 0; i < N; i++) {
		std::getline(std::cin, line);
		std::istringstream iss(line);
		std::string command;
		iss >> command;
		int value;

		if (command == "push_back") {
			iss >> value;
			myDeque.push_back(value);
		}

		if (command == "push_front") {
			iss >> value;
			myDeque.push_front(value);
		}

		if (command == "pop_back") {
			if (myDeque.getSize() == 0) {
				continue;
			}
			myDeque.pop_back();
		}

		if (command == "pop_front") {
			if (myDeque.getSize() == 0) {
				continue;
			}
			myDeque.pop_front();
		}

		if (command == "clear") {
			myDeque.clear();
		}

		if (command == "size") {
			std::cout << myDeque.getSize() << std::endl;
		}

		if (command == "get") {
			iss >> value;
			std::cout << myDeque[value] << std::endl;
		}

		if (command == "print") {
			if (myDeque.getSize() == 0) {
				std::cout << "empty" << std::endl;
			}
			else {
				myDeque.printElements();
			}
		}
	}
	return 0;
}