Least Frequently Used (LFU) Cache Implementation

// C++ Program to implement LFU Cache
// using array
#include <bits/stdc++.h>
using namespace std;

struct Node {
    int key, value;
    int timeStamp, cnt;

    Node(int key, int val, int timeStamp) {
        this->key = key;
        this->value = val;
        this->cnt = 1;
        this->timeStamp = timeStamp;
    }
};

class LFUCache {
  
  public:
    int capacity;
    int curSize;
    int curTime;
    vector<Node *> cacheList;

    // Constructor to initialize values
    LFUCache(int capacity) {
        this->capacity = capacity;
        curSize = 0;
        curTime = 0;
        cacheList.resize(capacity, nullptr);
    }

    // Function to get the key's value
    int get(int key) {

        curTime++;
        for (int i = 0; i < capacity; i++) {
            if (cacheList[i] != nullptr && cacheList[i]->key == key) {
                cacheList[i]->cnt++;
                cacheList[i]->timeStamp = curTime;
                return cacheList[i]->value;
            }
        }
        return -1;
    }

    // Function to put a key-value pair
    void put(int key, int value) {

        curTime++;

        if (capacity == 0)
            return;

        for (int i = 0; i < capacity; i++) {
            if (cacheList[i] != nullptr && cacheList[i]->key == key) {
                cacheList[i]->value = value;
                cacheList[i]->cnt++;
                cacheList[i]->timeStamp = curTime;
                return;
            }
        }

        if (curSize < capacity) {

            curSize++;
            for (int i = 0; i < capacity; i++) {
                if (cacheList[i] == nullptr) {
                    cacheList[i] = new Node(key, value, curTime);
                    return;
                }
            }
        }

        else {
            int minCnt = INT_MAX, minTime = INT_MAX, minIndex = -1;
            for (int i = 0; i < capacity; i++) {

                if (cacheList[i]->cnt < minCnt ||
                    (cacheList[i]->cnt == minCnt && cacheList[i]->timeStamp < minTime)) {
                    minCnt = cacheList[i]->cnt;
                    minTime = cacheList[i]->timeStamp;
                    minIndex = i;
                }
            }
            cacheList[minIndex] = new Node(key, value, curTime);
        }
    }
};

int main() {

    LFUCache cache(2);

    cache.put(1, 1);
    cache.put(2, 2);
    cout << cache.get(1) << " ";
    cache.put(3, 3);
    cout << cache.get(2) << " ";
    cache.put(4, 4);
    cout << cache.get(3) << " ";
    cout << cache.get(4) << " ";
    cache.put(5, 5);

    return 0;
}

// C++ Program to implement LFU Cache
// using singly linked list
#include<bits/stdc++.h>
using namespace std;

struct Node {
    int key, value;
    int timeStamp, cnt;
    Node *next;

    Node(int key, int val, int timeStamp) {
        this->key = key;
        this->value = val;
        this->cnt = 1;
        this->timeStamp = timeStamp;
        this->next = nullptr;
    }
};

//LFU Cache class
class LFUCache {
public:

int capacity;
int curSize;
int curTime;
Node* head;

// Constructor to initialize values
LFUCache(int capacity) {
    this->capacity = capacity;
    curSize = 0;
    curTime = 0;
    head = new Node(-1, -1, -1);
}

// Function to get the key's value
int get(int key) {

    curTime++;
    Node* temp = head;

    while(temp->next != nullptr) {
        if(temp->next->key == key) {
            temp->next->cnt++;
            temp->next->timeStamp = curTime;
            return temp->next->value;
        }
        temp = temp->next;
    }
    return -1;  
}

// Function to put a key-value pair
void put(int key, int value) {
    
    curTime++;
    if(capacity == 0) return;
    Node* temp = head;

    while(temp->next != nullptr) {
        if(temp->next->key == key) {
            temp->next->value = value;
            temp->next->cnt++;
            temp->next->timeStamp = curTime;
            return;
        }
        temp = temp->next;
    }

    if(curSize < capacity) {

        curSize++;
        Node* temp = head;

        while(temp->next != nullptr) {
            temp = temp->next;
        }
        temp->next = new Node(key, value, curTime);
        return;
    } 
    
    else {
        int minCnt = INT_MAX, minTime = INT_MAX;
        Node* minNode = nullptr;
        Node* temp = head;

        while(temp->next != nullptr) {
            if(temp->next->cnt < minCnt ||
                    (temp->next->cnt == minCnt &&
                        temp->next->timeStamp < minTime)) {
                minCnt = temp->next->cnt;
                minTime = temp->next->timeStamp;
                minNode = temp;
            }
            temp = temp->next;
        }
        Node* delNode = minNode->next;
        minNode->next = minNode->next->next;
        delete delNode;
        
        temp = head;
        while(temp->next != nullptr) {
            temp = temp->next;
        }
        temp->next = new Node(key, value, curTime);
    }
}
};

int main(){
    LFUCache cache(2);
  
    cache.put(1, 1); 
    cache.put(2, 2);
    cout << cache.get(1) << " ";
    cache.put(3, 3);
    cout << cache.get(2) << " ";
    cache.put(4, 4);
    cout << cache.get(3) << " ";
  	cout << cache.get(4) << " ";
    cache.put(5, 5);
    return 0;
}

// C++ Program to implement LFU (Least Frequently Used) cache
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int key; 
    int value;
    int cnt;   
    Node *next;
    Node *prev;
  
    Node(int key, int val) {
        this->key = key;
        this->value = val;

        // Initial frequency is 1
        cnt = 1; 
    }
};

// LFU Cache class
class LFUCache {
public:

    // Maps a key to the corresponding Node
    unordered_map<int, Node *> cacheMap;

    // Maps frequency to a pair of head and tail pointers
    unordered_map<int, pair<Node *, Node *>> freqMap;

    // Tracks the minimum frequency of the cache
    int minFreq;

    // Maximum capacity of the cache
    int capacity;

    // Constructor to initialize LFUCache with a given capacity
    LFUCache(int capacity) {
        this->capacity = capacity;
        
        // Initial minimum frequency is 0
        minFreq = 0; 
    }

    // Function to get the value associated with a key
    int get(int key) {

        // Return -1 if key is not found in the cache
        if (cacheMap.find(key) == cacheMap.end()) {
            return -1;
        }

        // Retrieve the Node and update its frequency
        Node *node = cacheMap[key];
        int res = node->value;
        updateFreq(node);
        return res;
    }

    // Function to add or update a key-value pair in the cache
    void put(int key, int value) {

        // Do nothing if the cache has zero capacity
        if (capacity == 0)
            return;

        // Update value if key already exists in the cache
        if (cacheMap.find(key) != cacheMap.end()) {

            Node *node = cacheMap[key];
            node->value = value;
            updateFreq(node);
        }

        // Add a new key-value pair to the cache
        else {

            // Remove the least frequently used node if cache is full
            if (cacheMap.size() == capacity) {

                Node *node = freqMap[minFreq].second->prev;
                cacheMap.erase(node->key);
                remove(node);

                // Remove the frequency list if it's empty
                if (freqMap[minFreq].first->next == freqMap[minFreq].second) {
                    freqMap.erase(minFreq);
                }

                // Free memory
                delete node; 
            }

            // Create a new node for the key-value pair
            Node *node = new Node(key, value);
            cacheMap[key] = node;
            
            // Reset minimum frequency to 1
            minFreq = 1; 
            add(node, 1);
        }
    }

    // Add a node to the frequency list
    void add(Node *node, int freq) {

        // Initialize the frequency list if it doesn't exist
        if (freqMap.find(freq) == freqMap.end()) {

            // Dummy head node
            Node *head = new Node(-1, -1); 
            
            // Dummy tail node
            Node *tail = new Node(-1, -1); 
            head->next = tail;
            tail->prev = head;
            freqMap[freq] = {head, tail};
        }

        // Insert the node right after the head
        Node *head = freqMap[freq].first;
        Node *temp = head->next;
        node->next = temp;
        node->prev = head;
        head->next = node;
        temp->prev = node;
    }

    // Remove a node from the frequency list
    void remove(Node *node) {

        // Update pointers to exclude the node
        Node *delprev = node->prev;
        Node *delnext = node->next;
        delprev->next = delnext;
        delnext->prev = delprev;
    }

    // Update the frequency of a node
    void updateFreq(Node *node) {

        // Get the current frequency
        int oldFreq = node->cnt; 

        // Increment the frequency
        node->cnt++; 

        // Remove the node from the current frequency list
        remove(node);

        // Remove the frequency list if it becomes empty
        if (freqMap[oldFreq].first->next == freqMap[oldFreq].second) {
            freqMap.erase(oldFreq);
            
            // Update minimum frequency if needed
            if (minFreq == oldFreq) {
                minFreq++;
            }
        }

        // Add the node to the updated frequency list
        add(node, node->cnt);
    }
};

int main() {

    LFUCache cache(2);

    cache.put(1, 1);
    cache.put(2, 2);
    cout << cache.get(1) << " ";
    cache.put(3, 3);
    cout << cache.get(2) << " ";
    cache.put(4, 4);
    cout << cache.get(3) << " ";
    cout << cache.get(4) << " ";
    cache.put(5, 5);

    return 0;
}