LRU cache

struct Node
{
	int id;
	char val[100];
	Node *prev;
	Node *next;
};

class DoubleLinkedList
{
public:
	DoubleLinkedList()
	{
		head = tail = NULL;
		size = 0;
	}
	int Size()
	{
		return size;
	}
	void InsertHead(Node *newHead)
	{
		if(NULL == head && NULL == tail)
			head = tail = newHead;
		else
		{
			newHead->next = head;
			newHead->prev = NULL;
			head->prev = newHead;
			head = newHead;
		}
		++size;
	}
	void DeleteTail()
	{
		delete remove(tail);
	}
	void Visit(Node *node)
	{
		remove(node);
		InsertHead(node);
	}

private:
	Node *remove(Node *del)
	{
		if(size <= 0)
			return NULL;
		if(--size == 0)
			head = tail = NULL;
		else if(del == head)
		{
			head = head->next;
			head->prev = NULL;
		}
		else if(del == tail)
		{
			tail = tail->prev;
			tail->next = NULL;
		}
		else
		{
			del->prev->next = del->next;
			del->next->prev = del->prev;
		}
		return del;
	}
	Node *head;
	Node *tail;
	int size;
};

class LRUCache
{
public:
	LRUCache(int limit):LIMIT(limit){}
	void Insert(int id, char *v)
	{
		while(list.Size() >= LIMIT)
			list.DeleteTail();
		Node *temp = new Node();
		temp->id = id;
		strcpy(temp->val, v);
		list.InsertHead(temp);
		umap[id] = temp;
	}
	void Update(int id, char *v)
	{
		unordered_map<int, Node*>::iterator it = umap.find(id);
		if(it != umap.end())
		{
			strcpy(it->second->val, v);
			list.Visit(it->second);
		}
	}
	char *Search(int id)
	{
		unordered_map<int, Node*>::iterator it = umap.find(id);
		if(it != umap.end())
		{
			list.Visit(it->second);
			return it->second->val;
		}
		return NULL;
	}
private:
	const int LIMIT;
	DoubleLinkedList list;
	unordered_map<int, Node*> umap;
};

int main()
{
	
	return 0;
}