重写一个类型为template<typename K, typename V>的map模板类和对应的map迭代器

好的，以下是重写的代码：

template<typename K, typename V>
class myMap{
private:
    struct Node{
        K key;
        V value;
        Node* left;
        Node* right;
        Node(K k, V v):key(k), value(v), left(nullptr), right(nullptr){}
    };
    Node* root;
    int count;

public:
    myMap():root(nullptr), count(0){}

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    void insert(K key, V value){
        root = insert(root, key, value);
    }

    bool contain(K key){
        return contain(root, key);
    }

    V* search(K key){
        return search(root, key);
    }

    void remove(K key){
        root = remove(root, key);
    }

    Node* minimum(Node* node){
        if(node->left == nullptr)
            return node;
        return minimum(node->left);
    }

    Node* maximum(Node* node){
        if(node->right == nullptr)
            return node;
        return maximum(node->right);
    }

    Node* removeMin(Node* node){
        if(node->left == nullptr){
            Node* rightNode = node->right;
            delete node;
            count--;
            return rightNode;
        }
        node->left = removeMin(node->left);
        return node;
    }

    Node* removeMax(Node* node){
        if(node->right == nullptr){
            Node* leftNode = node->left;
            delete node;
            count--;
            return leftNode;
        }
        node->right = removeMax(node->right);
        return node;
    }

    Node* successor(Node* node, K key){
        if(node == nullptr)
            return nullptr;
        if(node->key == key){
            if(node->right != nullptr)
                return minimum(node->right);
        }
        else if(node->key < key){
            return successor(node->right, key);
        }
        else{
            Node* left = successor(node->left, key);
            if(left != nullptr)
                return left;
            else
                return node;
        }
    }

    Node* predecessor(Node* node, K key){
        if(node == nullptr)
            return nullptr;
        if(node->key == key){
            if(node->left != nullptr)
                return maximum(node->left);
        }
        else if(node->key > key){
            return predecessor(node->left, key);
        }
        else{
            Node* right = predecessor(node->right, key);
            if(right != nullptr)
                return right;
            else
                return node;
        }
    }

    Node* insert(Node* node, K key, V value){
        if(node == nullptr){
            count++;
            return new Node(key, value);
        }
        if(key == node->key)
            node->value = value;
        else if(key < node->key)
            node->left = insert(node->left, key, value);
        else
            node->right = insert(node->right, key, value);
        return node;
    }

    bool contain(Node* node, K key){
        if(node == nullptr)
            return false;
        if(key == node->key)
            return true;
        else if(key < node->key)
            return contain(node->left, key);
        else
            return contain(node->right, key);
    }

    V* search(Node* node, K key){
        if(node == nullptr)
            return nullptr;
        if(key == node->key)
            return &node->value;
        else if(key < node->key)
            return search(node->left, key);
        else
            return search(node->right, key);
    }

    Node* remove(Node* node, K key){
        if(node == nullptr)
            return nullptr;
        if(key == node->key){
            if(node->left == nullptr){
                Node* rightNode = node->right;
                delete node;
                count--;
                return rightNode;
            }
            if(node->right == nullptr){
                Node* leftNode = node->left;
                delete node;
                count--;
                return leftNode;
            }
            Node* successorNode = new Node(minimum(node->right)->key, minimum(node->right)->value);
            count++;
            successorNode->left = node->left;
            successorNode->right = removeMin(node->right);
            delete node;
            count--;
            return successorNode;
        }
        else if(key < node->key){
            node->left = remove(node->left, key);
            return node;
        }
        else{
            node->right = remove(node->right, key);
            return node;
        }
    }
    
    class iterator{
    private:
        stack<Node*> s;
        Node* node;
    public:
        iterator(Node* root){
            node = root;
            while(node != nullptr){
                s.push(node);
                node = node->left;
            }
        }

        iterator(){}

        bool hasNext(){
            return !s.empty();
        }

        Node* next(){
            if(!hasNext())
                return nullptr;
            node = s.top();
            s.pop();
            Node* res = node;
            node = node->right;
            while(node != nullptr){
                s.push(node);
                node = node->left;
            }
            return res;
        }

        V& operator*(){
            return node->value;
        }

        bool operator==(const iterator& it){
            return node == it.node;
        }

        bool operator!=(const iterator& it){
            return node != it.node;
        }
    };

    iterator begin(){
        return iterator(minimum(root));
    }

    iterator end(){
        return iterator(nullptr);
    }

};

以上是重写的myMap模板类，包含了插入、查找、删除等基本操作，并且还实现了迭代器。