Generally Interviewer can ask you simply to implement LRU cache, first explain which data structure you will use and why.
Its well known coding question being asked by all Tech giants like Amazon , Flipkart, Microsoft.
LRU (Least Recently Used) Cache holds Page numbers which are recently used and throws out old or least recently used page number or entries.
For LRU Important fenomenon is “aging”.
When a page is referenced, it will be “young” (latest) and if its not referenced/called its will be “old”.
If a page is moderately old and get referenced, its young again.
So Entries in LRU Cache goes to and fro frequently.
Q1) Which kind of data structure is good for this ?
Array ? Stack ? Queue ? Link List ??? Obviously Link List.
As with just movement of two pointer we can move any node(which contains page number ) to and fro easily.
Q2) Which data structure will be useful to implement new and old referenced page number(node)
Array? Stack ? Queue ??? Queue is Answer right
So to implement LRU Cache we can use Queue implemented with Linked List.
Q3) How can we search efficiently that one page is referenced is in queue already?
Every time search queue in O(n) ?
Better Approch is to use Hash which stores page number which are in queue.
Better Approch is to use Hash which stores page number which are in queue.
so DS used : Queue with LL and Hash
Sample code we have compiled and put
#include<iostream>
#include<map>
using namespace std;
struct node
{
int pg;
struct node *next, *prev;
};
class LRUCache
{
int size;
int MAXSZ;
struct node *head,*tail;
public:
LRUCache(int maxsize){
MAXSZ=maxsize;
size=0;
head=new node();
tail=new node();
head->pg= tail->pg=-1;
head->next= tail;
head->prev= tail->next= NULL;
tail->prev= head;
}
map<int, struct node *> m;
void add_to_head(node * );
void remove_from_list(node *);
public:
void get();
void put (int pgno);
};
void LRUCache::add_to_head(struct node *n){
n->next= head->next;
n->prev= head;
n->next->prev= n;
head->next= n;
}
void LRUCache::remove_from_list(node *n){
if (size==0)
return;
n->prev->next= n->next;
n->next->prev= n->prev;
}
void LRUCache::put(int pgno){
if (m.find(pgno)==m.end()){
if (size >= MAXSZ)
{
m.erase(tail->prev->pg);
remove_from_list(tail->prev);
}
else size++;
struct node *nn = new node();
nn->pg=pgno;
add_to_head(nn);
m.insert(make_pair(pgno,nn));
}
else{
struct node *n= m[pgno];
remove_from_list(n);
add_to_head(n);
}
}
void LRUCache::get(){
struct node *temp=head;
while (temp!=NULL){
cout << temp->pg << " ";
temp=temp->next;
}
cout << endl;
}
int main(){
LRUCache lru(3); //specify size
lru.get();
lru.put(1);
lru.put(2);
lru.get();
lru.put(1);
lru.get();
lru.put(3);
lru.get();
lru.put(4);
lru.get();
return 0;
}
You can see Working code Here : http://ideone.com/DFql9R