STL09——手写一个简单版本的map(包含map的特点、使用方法）

1.特点：

• 键值对：键值对的形式存储数据
• 有序性：根据键升序排列（因为底层是红黑树）
• 唯一性：键必须是唯一的。如果尝试插入一个已存在的键，插入操作将失败。
• 直接访问：可以使用键直接访问std::map中的元素，如：map[2]，及访问键为2的value值

2.基本用法：

• 插入元素：

myMap.insert({1,100});
myMap[2] = 200; // 使用下标操作符直接插入或修改

• 查找元素

cout<<myMap[2]<<endl;

• 删除元素

  myMap.erase(2)

手写一个简单版本的map

【STL 专题之 map】map 的实现

题目描述

本题需要设计一个 map 类，实现如下功能：

1、基础功能

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

2、核心功能

• 在 map 中插入一个元素
• 在 map 中删除元素
• 判断一个元素是否在 map 中
• 判断 map 是否为空
• 获取 map 的大小
• 获取 map 中 key 对应的 value

输入描述

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

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

insert 命令：

• 格式：insert [key] [value]
• 功能：在 map 中添加 key-value 键值对，如果对应的 key 已经存在，则不进行任何操作

erase 命令：

• 格式：erase [key]
• 功能：删除 map 中 key 对应的键值对，如果 key 不存在，则不进行任何操作

contains 命令：

• 格式：contains [key]
• 功能：查询 map 中 element 的数量

empty 命令：

• 格式：empty
• 功能：判断 map 是否为空

size 命令：

• 格式：size
• 功能：获取 map 的大小

at 命令：

• 格式：at [key]
• 功能：查询 map 中 key 对应的 value

#include "RedBlackTree.h"
#include <iostream>
#include <utility>

template<typename Key,typename Value>
class Map
{
private:
	RedBlackTree<Key, Value> rbTree;
public:
	Map() :rbTree() {}

	~Map(){}

	void insert(const Key& key, const Value& value) { rbTree.insert(key, value); }

	void erase(const Key& key) { rbTree.remove(key); }

	size_t size() { return rbTree.getSize(); }

	bool empty() const { return rbTree.empty(); }

	bool contains(const Key& key) { return rbTree.at(key) != nullptr; }

	Value& at(const Key &key)
	{
		Value* Val = rbTree.at(key);
		if (Val != NULL)
			return *Val;
		else
			throw out_of_range("Key not found");
	}

	Value& operator[](const Key& key)
	{
		Value* Val = rbTree.at(key);
		if (Val != NULL)
			return *Val;
		else
		{
			Value defaultValue;//默认值
			rbTree.insert(key, defaultValue);
			return rbTree.at(key);
		}
	}
}; 

int main() {
    Map<int, int> map;

    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 key;
        int value;

        if (command == "insert") {
            iss >> key >> value;
            map.insert(key, value);
        }

        if (command == "erase") {
            iss >> key;
            map.erase(key);
        }

        if (command == "contains") {
            iss >> key;
            if (map.contains(key)) {
                std::cout << "true" << std::endl;
            }
            else {
                std::cout << "false" << std::endl;
            }
        }

        if (command == "at") {
            iss >> key;
            try {
                std::cout << map.at(key) << std::endl;
            }
            catch (const std::out_of_range& e) {
                std::cout << "not exsit" << std::endl;
            }
        }

        // size 命令
        if (command == "size") {
            std::cout << map.size() << std::endl;
        }

        // empty 命令
        if (command == "empty") {
            if (map.empty()) {
                std::cout << "true" << std::endl;
            }
            else {
                std::cout << "false" << std::endl;
            }
        }
    }
    return 0;
}