Skip to content

Commit 480025a

Browse files
maolonglongmaolonglong
committed
feat: add rust solution to lc problem: No.0146.Lru Cache
1 parent 23f1710 commit 480025a

File tree

3 files changed

+386
-10
lines changed

3 files changed

+386
-10
lines changed

‎solution/0100-0199/0146.Lru Cache/README.md

+132-5
Original file line numberDiff line numberDiff line change
@@ -146,15 +146,15 @@ class LRUCache:
146146
node = self.remove_tail()
147147
self.cache.pop(node.key)
148148
self.size -= 1
149-
149+
150150
def move_to_head(self, node):
151151
self.remove_node(node)
152152
self.add_to_head(node)
153-
153+
154154
def remove_node(self, node):
155155
node.prev.next = node.next
156156
node.next.prev = node.prev
157-
157+
158158
def add_to_head(self, node):
159159
node.next = self.head.next
160160
self.head.next.prev = node
@@ -207,7 +207,7 @@ class LRUCache {
207207
head.next = tail;
208208
tail.prev = head;
209209
}
210-
210+
211211
public int get(int key) {
212212
if (!cache.containsKey(key)) {
213213
return -1;
@@ -216,7 +216,7 @@ class LRUCache {
216216
moveToHead(node);
217217
return node.value;
218218
}
219-
219+
220220
public void put(int key, int value) {
221221
if (cache.containsKey(key)) {
222222
Node node = cache.get(key);
@@ -267,6 +267,133 @@ class LRUCache {
267267
*/
268268
```
269269

270+
### **Rust**
271+
272+
```rust
273+
use std::cell::RefCell;
274+
use std::collections::hash_map::HashMap;
275+
use std::rc::Rc;
276+
277+
struct Node {
278+
key: i32,
279+
value: i32,
280+
prev: Option<Rc<RefCell<Node>>>,
281+
next: Option<Rc<RefCell<Node>>>,
282+
}
283+
284+
impl Node {
285+
#[inline]
286+
fn new(key: i32, value: i32) -> Node {
287+
Node {
288+
key,
289+
value,
290+
prev: None,
291+
next: None,
292+
}
293+
}
294+
}
295+
296+
struct LRUCache {
297+
capacity: usize,
298+
cache: HashMap<i32, Rc<RefCell<Node>>>,
299+
head: Option<Rc<RefCell<Node>>>,
300+
tail: Option<Rc<RefCell<Node>>>,
301+
}
302+
303+
impl LRUCache {
304+
fn new(capacity: i32) -> Self {
305+
LRUCache {
306+
capacity: capacity as usize,
307+
cache: HashMap::new(),
308+
head: None,
309+
tail: None,
310+
}
311+
}
312+
313+
fn get(&mut self, key: i32) -> i32 {
314+
if let Some(node) = self.cache.get(&key) {
315+
let node = Rc::clone(node);
316+
self.remove(&node);
317+
self.push_front(&node);
318+
let value = node.borrow().value;
319+
value
320+
} else {
321+
-1
322+
}
323+
}
324+
325+
fn put(&mut self, key: i32, value: i32) {
326+
if let Some(node) = self.cache.get(&key) {
327+
let node = Rc::clone(node);
328+
node.borrow_mut().value = value;
329+
self.remove(&node);
330+
self.push_front(&node);
331+
} else {
332+
let node = Rc::new(RefCell::new(Node::new(key, value)));
333+
self.cache.insert(key, Rc::clone(&node));
334+
self.push_front(&node);
335+
if self.cache.len() > self.capacity {
336+
if let Some(back) = self.pop_back() {
337+
self.cache.remove(&back.borrow().key);
338+
}
339+
}
340+
}
341+
}
342+
343+
fn push_front(&mut self, node: &Rc<RefCell<Node>>) {
344+
let mut node_borrow_mut = node.borrow_mut();
345+
if let Some(head) = self.head.take() {
346+
head.borrow_mut().prev = Some(Rc::clone(node));
347+
node_borrow_mut.next = Some(head);
348+
node_borrow_mut.prev = None;
349+
self.head = Some(Rc::clone(node));
350+
} else {
351+
self.head = Some(Rc::clone(node));
352+
self.tail = Some(Rc::clone(node));
353+
}
354+
}
355+
356+
fn remove(&mut self, node: &Rc<RefCell<Node>>) {
357+
match (node.borrow().prev.as_ref(), node.borrow().next.as_ref()) {
358+
(None, None) => {
359+
self.head = None;
360+
self.tail = None;
361+
}
362+
(None, Some(next)) => {
363+
self.head = Some(Rc::clone(next));
364+
next.borrow_mut().prev = None;
365+
}
366+
(Some(prev), None) => {
367+
self.tail = Some(Rc::clone(prev));
368+
prev.borrow_mut().next = None;
369+
}
370+
(Some(prev), Some(next)) => {
371+
next.borrow_mut().prev = Some(Rc::clone(prev));
372+
prev.borrow_mut().next = Some(Rc::clone(next));
373+
}
374+
}
375+
}
376+
377+
fn pop_back(&mut self) -> Option<Rc<RefCell<Node>>> {
378+
if let Some(tail) = self.tail.take() {
379+
match tail.borrow().prev.as_ref() {
380+
Some(prev) => {
381+
prev.borrow_mut().next = None;
382+
self.tail = Some(Rc::clone(prev));
383+
}
384+
None => {
385+
self.head = None;
386+
self.tail = None;
387+
}
388+
}
389+
Some(tail)
390+
} else {
391+
None
392+
}
393+
}
394+
}
395+
```
396+
270397
### **...**
271398

272399
```

‎solution/0100-0199/0146.Lru Cache/README_EN.md

+132-5
Original file line numberDiff line numberDiff line change
@@ -96,15 +96,15 @@ class LRUCache:
9696
node = self.remove_tail()
9797
self.cache.pop(node.key)
9898
self.size -= 1
99-
99+
100100
def move_to_head(self, node):
101101
self.remove_node(node)
102102
self.add_to_head(node)
103-
103+
104104
def remove_node(self, node):
105105
node.prev.next = node.next
106106
node.next.prev = node.prev
107-
107+
108108
def add_to_head(self, node):
109109
node.next = self.head.next
110110
self.head.next.prev = node
@@ -155,7 +155,7 @@ class LRUCache {
155155
head.next = tail;
156156
tail.prev = head;
157157
}
158-
158+
159159
public int get(int key) {
160160
if (!cache.containsKey(key)) {
161161
return -1;
@@ -164,7 +164,7 @@ class LRUCache {
164164
moveToHead(node);
165165
return node.value;
166166
}
167-
167+
168168
public void put(int key, int value) {
169169
if (cache.containsKey(key)) {
170170
Node node = cache.get(key);
@@ -215,6 +215,133 @@ class LRUCache {
215215
*/
216216
```
217217

218+
### **Rust**
219+
220+
```rust
221+
use std::cell::RefCell;
222+
use std::collections::hash_map::HashMap;
223+
use std::rc::Rc;
224+
225+
struct Node {
226+
key: i32,
227+
value: i32,
228+
prev: Option<Rc<RefCell<Node>>>,
229+
next: Option<Rc<RefCell<Node>>>,
230+
}
231+
232+
impl Node {
233+
#[inline]
234+
fn new(key: i32, value: i32) -> Node {
235+
Node {
236+
key,
237+
value,
238+
prev: None,
239+
next: None,
240+
}
241+
}
242+
}
243+
244+
struct LRUCache {
245+
capacity: usize,
246+
cache: HashMap<i32, Rc<RefCell<Node>>>,
247+
head: Option<Rc<RefCell<Node>>>,
248+
tail: Option<Rc<RefCell<Node>>>,
249+
}
250+
251+
impl LRUCache {
252+
fn new(capacity: i32) -> Self {
253+
LRUCache {
254+
capacity: capacity as usize,
255+
cache: HashMap::new(),
256+
head: None,
257+
tail: None,
258+
}
259+
}
260+
261+
fn get(&mut self, key: i32) -> i32 {
262+
if let Some(node) = self.cache.get(&key) {
263+
let node = Rc::clone(node);
264+
self.remove(&node);
265+
self.push_front(&node);
266+
let value = node.borrow().value;
267+
value
268+
} else {
269+
-1
270+
}
271+
}
272+
273+
fn put(&mut self, key: i32, value: i32) {
274+
if let Some(node) = self.cache.get(&key) {
275+
let node = Rc::clone(node);
276+
node.borrow_mut().value = value;
277+
self.remove(&node);
278+
self.push_front(&node);
279+
} else {
280+
let node = Rc::new(RefCell::new(Node::new(key, value)));
281+
self.cache.insert(key, Rc::clone(&node));
282+
self.push_front(&node);
283+
if self.cache.len() > self.capacity {
284+
if let Some(back) = self.pop_back() {
285+
self.cache.remove(&back.borrow().key);
286+
}
287+
}
288+
}
289+
}
290+
291+
fn push_front(&mut self, node: &Rc<RefCell<Node>>) {
292+
let mut node_borrow_mut = node.borrow_mut();
293+
if let Some(head) = self.head.take() {
294+
head.borrow_mut().prev = Some(Rc::clone(node));
295+
node_borrow_mut.next = Some(head);
296+
node_borrow_mut.prev = None;
297+
self.head = Some(Rc::clone(node));
298+
} else {
299+
self.head = Some(Rc::clone(node));
300+
self.tail = Some(Rc::clone(node));
301+
}
302+
}
303+
304+
fn remove(&mut self, node: &Rc<RefCell<Node>>) {
305+
match (node.borrow().prev.as_ref(), node.borrow().next.as_ref()) {
306+
(None, None) => {
307+
self.head = None;
308+
self.tail = None;
309+
}
310+
(None, Some(next)) => {
311+
self.head = Some(Rc::clone(next));
312+
next.borrow_mut().prev = None;
313+
}
314+
(Some(prev), None) => {
315+
self.tail = Some(Rc::clone(prev));
316+
prev.borrow_mut().next = None;
317+
}
318+
(Some(prev), Some(next)) => {
319+
next.borrow_mut().prev = Some(Rc::clone(prev));
320+
prev.borrow_mut().next = Some(Rc::clone(next));
321+
}
322+
}
323+
}
324+
325+
fn pop_back(&mut self) -> Option<Rc<RefCell<Node>>> {
326+
if let Some(tail) = self.tail.take() {
327+
match tail.borrow().prev.as_ref() {
328+
Some(prev) => {
329+
prev.borrow_mut().next = None;
330+
self.tail = Some(Rc::clone(prev));
331+
}
332+
None => {
333+
self.head = None;
334+
self.tail = None;
335+
}
336+
}
337+
Some(tail)
338+
} else {
339+
None
340+
}
341+
}
342+
}
343+
```
344+
218345
### **...**
219346

220347
```

0 commit comments

Comments
 (0)