————2020.1.15————

# 学习记录 || Coding_Record #

---

# LRU

比较常见的页面置换算法。*leetcode 146

# 个人简易实现(Java)

 1 import java.util.HashMap;
 2 
 3 
 4 class LRUCache {
 5     
 6     public static class Node{
 7         public Object val;
 8         public Object key;
 9         public Node next;
10         public Node last;
11         
12         public Node(Object key,Object val) {
13             this.val = val;
14             this.key = key;
15         }
16     }
17     
18     public static class DoubleList{
19         private Node head;
20         private Node tail;
21         public int size;
22         
23         public DoubleList() {
24             this.size = 0;
25             this.head = new Node(0,0);
26             this.tail = new Node(0,0);
27             head.next = tail;
28             head.last = null;
29             tail.last = head;
30             tail.next = null;
31         }
32         
33         public void addToHead(Node node) {
34             Node tmp = head.next;
35             head.next = node;
36             tmp.last = node;
37             node.last = head;
38             node.next = tmp;
39             size++;
40         }
41         
42         public Node removeLast() {
43             Node tmp = tail.last;
44             tmp.last.next = tail;
45             tail.last = tmp.last;
46             size--;
47             return tmp;
48         }
49         
50         public void moveToHead(Node node) {
51             node.last.next = node.next;
52             node.next.last = node.last;
53             size--;
54             addToHead(node);
55         }
56         
57     }
58     private int capacity;
59     
60     private DoubleList list = new DoubleList();
61     
62     private HashMap<Object,Node> map = new HashMap<>();
63     
64     public LRUCache(int capacity) {
65         this.capacity = capacity;
66     }
67     
68     public void put(Object key,Object value) {
69         Node node = map.get(key);
70         if(node!=null) {
71             node.val = value;
72             list.moveToHead(node);
73         }
74         else {
75             Node newNode = new Node(key,value);
76             if(list.size==capacity) {
77                 Node delnode = list.removeLast();
78                 map.remove(delnode.key);
79             }
80             list.addToHead(newNode);
81             map.put(key,newNode);
82         }
83     }
84     
85     public Object get(Object key) {
86         Node node = map.get(key);
87         if(node==null) return -1;
88         else {
89             list.moveToHead(node);
90             return node.val;
91         }
92     }
93 }

# SkipList

基于链表的随机化数据结构，易于实现且性能高，应用如Redis中SortedSet。 *leetcode 1206

# 参考leetcode题解的手写简易实现(Java)

  1 import java.util.ArrayList;
  2 import java.util.List;
  3 
  4 
  5 public class SkipList {
  6     
  7     public class SkipListNode{
  8         
  9         public Integer value;
 10         public SkipListNode right;
 11         public SkipListNode left;
 12         public SkipListNode down;
 13         
 14         public SkipListNode(Integer value) {
 15             this.value = value;
 16             this.down = null;
 17             this.right = null;
 18             this.left = null;
 19         }
 20     }
 21     
 22     private List<SkipListNode> heads ;
 23     
 24     public SkipList() {
 25         SkipListNode head_of_0 = new SkipListNode( Integer.MIN_VALUE );
 26         heads = new ArrayList<>();
 27         heads.add(head_of_0);
 28     }
 29     
 30     public boolean search(Integer target) {
 31         int level = heads.size()-1;
 32         SkipListNode curNode = heads.get(level);
 33         while(level != -1) {
 34             boolean jump = false;
 35             while(curNode.right != null) {
 36                 curNode = curNode.right;
 37                 if(curNode.value == target) {
 38                     return true;
 39                 }
 40                 else if(curNode.value > target) {
 41                     if(level == 0) return false;
 42                     else {
 43                         level--;
 44                         curNode = curNode.left;
 45                         jump = true;
 46                         break;
 47                     }
 48                 }
 49             }
 50             if(jump==true) continue;
 51             level--;
 52             curNode = curNode.down;
 53         }
 54         return false;
 55     }
 56     
 57     private void del(SkipListNode node){
 58         node.left.right = node.right;
 59         if(node.right != null ) {
 60             node.right.left = node.left;
 61         }
 62     }
 63     
 64     private boolean throwCoin(){
 65         return Math.random()<0.5f;
 66     }
 67     
 68     public SkipListNode[] searchNodes(Integer target) {
 69         int level = heads.size()-1;
 70         SkipListNode[] jumps = new SkipListNode[heads.size()];
 71         SkipListNode curNode = heads.get(level);
 72         while(level!=-1){
 73             boolean jump = false;
 74             while(curNode.right!= null){
 75                 curNode = curNode.right;
 76                 if(curNode.value == target) {
 77                     while(level!=-1){
 78                         jumps[level] = curNode;
 79                         curNode = curNode.down;
 80                         level --;
 81                     }
 82                     return jumps;
 83                 }
 84                 else if(curNode.value>target){
 85                     jumps[level] = curNode.left;
 86                     level --;
 87                     curNode = curNode.left.down;
 88                     jump = true;
 89                     break;
 90                 }
 91             }
 92             if(jump)
 93                 continue;
 94             jumps[level] = curNode;
 95             level --;
 96             curNode = curNode.down;
 97         }
 98         return jumps;
 99     }
100     
101     public void erase(Integer target) {
102         SkipListNode[] jmpt = searchNodes(target);
103         for (SkipListNode n:jmpt)
104             if(n.value == target){
105                 del(n);
106             }
107     }
108     
109     public void add(Integer num) {
110         SkipListNode curNode = new SkipListNode(num);
111         SkipListNode[] curNodes = searchNodes(num);
112         SkipListNode leftNode = curNodes[0];
113         curNode.right = leftNode.right;
114         curNode.left = leftNode;
115         if(leftNode.right!=null)
116             leftNode.right.left=curNode;
117         leftNode.right = curNode;
118         //Add Index
119         int curIndex = 1;
120         while(throwCoin()){
121             SkipListNode tmp;
122             if(curNodes.length <= curIndex){
123                 tmp= new SkipListNode(Integer.MIN_VALUE);
124                 heads.add(tmp);
125                 tmp.down = heads.get(curIndex-1);
126             }
127             else
128                 tmp = curNodes[curIndex];
129             SkipListNode curtmp = new SkipListNode(num);
130             curtmp.down = curNode;
131             curtmp.right = tmp.right;
132             curtmp.left = tmp;
133             if(tmp.right!=null)
134                 tmp.right.left = curtmp;
135             tmp.right = curtmp;
136             curNode = curtmp;
137             curIndex++;
138         }
139     }
140 }

---

# Edit : 2020.1.15