leetcode146

public class LRUCache
    {
        int Capacity = 0;
        int Curlen = 0;
        long sernumbers;
        long SerNumbers
        {
            get
            {
                if (sernumbers <= long.MaxValue)
                {
                    return sernumbers;
                }
                else
                {
                    dic.Clear();
                    return 0;
                }
            }
            set
            {
                sernumbers = value;
            }

        }
        Dictionary<int, KeyValuePair<int, long>> dic = new Dictionary<int, KeyValuePair<int, long>>();
        //外层的Key为LRU的key，
        //内层的Key为LRU的Value，内层的Value为访问编号

        public LRUCache(int capacity)
        {
            Capacity = capacity;
        }

        public int Get(int key)
        {
            if (dic.ContainsKey(key))
            {
                var K = dic[key].Key;
                dic[key] = new KeyValuePair<int, long>(K, SerNumbers++);
                return K;
            }
            else
            {
                return -1;
            }
        }

        public void Put(int key, int value)
        {
            if (dic.ContainsKey(key))
            {
                dic[key] = new KeyValuePair<int, long>(value, SerNumbers++);
            }
            else
            {
                if (Curlen < Capacity)
                {
                    dic.Add(key, new KeyValuePair<int, long>(value, SerNumbers++));
                    Curlen++;
                }
                else
                {
                    var evictkey = dic.OrderBy(x => x.Value.Value).FirstOrDefault().Key;
                    dic.Remove(evictkey);
                    dic.Add(key, new KeyValuePair<int, long>(value, SerNumbers++));
                }

            }
        }
    }

经典题目LRU被从Hard降低为Medium类别了，原来的实现有一点问题，

我又找了一个使用C#封装的数据结构LinkedList的实现，写起来更加简单。

linkedlist，链头记录最旧的数据，链尾记录最新的数据。

public class LRUCache
    {

        private readonly LinkedList<int> _queue;
        private readonly Dictionary<int, int> _dict;
        private readonly int _capacity;

        public LRUCache(int capacity)
        {
            _queue = new LinkedList<int>();
            _dict = new Dictionary<int, int>();
            _capacity = capacity;
        }

        public void Put(int key, int value)
        {
            if (_dict.TryGetValue(key, out var previousValue))
            {
                _dict.Remove(key);
                _queue.Remove(key);
            }

            if (_queue.Count == _capacity)
            {
                var first = _queue.First;
                _dict.Remove(first.Value);
                _queue.RemoveFirst();
            }

            _dict[key] = value;
            _queue.AddLast(key);
        }

        public int Get(int key)
        {
            if (!_dict.TryGetValue(key, out int value))
            {
                return -1;
            }

            _queue.Remove(key);

            _queue.AddLast(key);

            return value;
        }
    }