Solution Review: Prefix Map

#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
using namespace std;

// Definition of TrieNode
class TrieNode
{
    public:
       	// An integer to store the total value associated with every node and it's children
        int val;
       	// children array store pointer to TrieNode of next 26 alphabets
        TrieNode *children[26];
};

class Trie
{
    public:
        // intialize a hashmap
        unordered_map<string, int> keyToValMap;

        // intialize the trie root
        TrieNode * root;
        Trie()
        {
            root = new TrieNode();
        }
    
       	// function to insert key value data in the trie
        bool insert(string key, int diff)
        {
            // point the current node to the root
            TrieNode *curr = root;

            // intialize an integer value to count insertions in the trie
            int insertions = 0;

            // iterate through the letters of the key
            for (int i = 0; i < key.size(); i++)
            {
                int c = key[i] - 'a';
                if (curr->children[c] == nullptr)
                {
                    curr->children[c] = new TrieNode();
                    insertions++;
                }
    
                // move to the child node
                curr = curr->children[c];
    
               	// add the diff value to the node's original value
                curr->val += diff;
            }
            
            // if insertion count is greater than zero
            // means the key did not previously exist, true is returned
            return insertions > 0;
        }
    
        int search(string word)
        {
            TrieNode *curr = root;
           	//traverse the trie starting from the root
            for (char c: word)
            {
                c -= 'a';
                // if there is no node for a query letter in trie
                // return false and terminate the search
                if (curr->children[c] == nullptr)
                {
                    return 0;
                }
    
                curr = curr->children[c];
            }
    
           	// return the val associated with the last node of query string
            return curr->val;
        }
};

class PrefixMap
{
    public:
        // initialize a trie
        Trie *trie = new Trie();

        bool putInMap(string key, int val)
        {
            int oldVal = trie->keyToValMap[key];
            trie->keyToValMap[key] = val;
    
           	// calculate the value difference 
           	// before updating in the hashmap
            int updateDiff = val - oldVal;
            return trie->insert(key, updateDiff);
        }
    
        int getSum(string prefixKey)
        {
            return trie->search(prefixKey);
        }
};