LeetCode LRU Cache & Insertion Sort List

LRU Cache

  Total Accepted: 16727  Total Submissions: 120052 My Submissions

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

这一题需要O(log n)的复杂度才能过，于是可以借助map的红黑树。

trick是map里存的是list的iterator.

用list记录顺序。list大概是类似双向队列的东西。然后begin() end() front() back()竟然搞混了。

class LRUCache{
    struct CacheNode {
		int key;
		int val;
		CacheNode(int a, int b) : key(a), val(b) {}
	};

	public:
		LRUCache(int capacity) {
			cap = capacity;
		}

		int get(int key) {
			if (cacheMap.find(key) != cacheMap.end()) {
			    touch(key);
				return cacheList.begin()->val;
			}
			else 
				return -1;
		}

		int set(int key, int val) {
			if (cacheMap.find(key) != cacheMap.end()) {
			    touch(key);
				cacheMap[key]->val = val;
			}
			else {
				if (cacheList.size() >= cap) {
					cacheMap.erase(cacheList.back().key);
					cacheList.pop_back();
				}
				cacheList.push_front(CacheNode(key, val));
				cacheMap[key] = cacheList.begin();
			}
		}
		
		// CacheNode key already exists, so transfer it to begin of the list
		void touch(int key) {
		    // solution 1
		  //  cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
		    // solution 2
		    cacheList.push_front(*cacheMap[key]);
		    cacheList.erase(cacheMap[key]);
		    
		    cacheMap[key] = cacheList.begin();
		}

		int cap;
		map<int, list<CacheNode>::iterator> cacheMap;
		list<CacheNode> cacheList;
};

Insertion Sort List

  Total Accepted: 20174  Total Submissions: 79737 My Submissions

Sort a linked list using insertion sort.

指针类型的插入排序。

所以要用指针记录已经排好的头和尾。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        if (head == NULL) 
				return head;

			ListNode *ans = head;
			ListNode *tail = head;
			ListNode *p, *tmp;
			while (tail->next) {
				int val = tail->next->val;
				if (val < ans->val) {//insert to the front 
					tmp = tail->next;
					tail->next = tmp->next;
					tmp->next = ans;
					ans = tmp;
				}
				else {
					for (p = ans; p->next->val <= val && p != tail; p = p->next);
					if (p != tail) {
						tmp = tail->next;
						tail->next = tmp->next;
						tmp->next = p->next;
						p->next = tmp;
					}
					else 
						tail = tail->next;
				
			}
			return ans;   
    }
};