Skip to content

Commit b4c1b21

Browse files
maolonglongmaolonglong
committed
feat: update rust solution to lc problem: No.0146
No.0146.Lru Cache
1 parent 35c2690 commit b4c1b21

File tree

3 files changed

+171
-147
lines changed

3 files changed

+171
-147
lines changed

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

+57-49
Original file line numberDiff line numberDiff line change
@@ -269,7 +269,7 @@ class LRUCache {
269269

270270
```rust
271271
use std::cell::RefCell;
272-
use std::collections::hash_map::HashMap;
272+
use std::collections::HashMap;
273273
use std::rc::Rc;
274274

275275
struct Node {
@@ -281,8 +281,8 @@ struct Node {
281281

282282
impl Node {
283283
#[inline]
284-
fn new(key: i32, value: i32) -> Node {
285-
Node {
284+
fn new(key: i32, value: i32) -> Self {
285+
Self {
286286
key,
287287
value,
288288
prev: None,
@@ -298,9 +298,13 @@ struct LRUCache {
298298
tail: Option<Rc<RefCell<Node>>>,
299299
}
300300

301+
/**
302+
* `&self` means the method takes an immutable reference.
303+
* If you need a mutable reference, change it to `&mut self` instead.
304+
*/
301305
impl LRUCache {
302306
fn new(capacity: i32) -> Self {
303-
LRUCache {
307+
Self {
304308
capacity: capacity as usize,
305309
cache: HashMap::new(),
306310
head: None,
@@ -309,46 +313,51 @@ impl LRUCache {
309313
}
310314

311315
fn get(&mut self, key: i32) -> i32 {
312-
if let Some(node) = self.cache.get(&key) {
313-
let node = Rc::clone(node);
314-
self.remove(&node);
315-
self.push_front(&node);
316-
let value = node.borrow().value;
317-
value
318-
} else {
319-
-1
316+
match self.cache.get(&key) {
317+
Some(node) => {
318+
let node = Rc::clone(node);
319+
self.remove(&node);
320+
self.push_front(&node);
321+
let value = node.borrow().value;
322+
value
323+
}
324+
None => -1,
320325
}
321326
}
322327

323328
fn put(&mut self, key: i32, value: i32) {
324-
if let Some(node) = self.cache.get(&key) {
325-
let node = Rc::clone(node);
326-
node.borrow_mut().value = value;
327-
self.remove(&node);
328-
self.push_front(&node);
329-
} else {
330-
let node = Rc::new(RefCell::new(Node::new(key, value)));
331-
self.cache.insert(key, Rc::clone(&node));
332-
self.push_front(&node);
333-
if self.cache.len() > self.capacity {
334-
if let Some(back) = self.pop_back() {
335-
self.cache.remove(&back.borrow().key);
329+
match self.cache.get(&key) {
330+
Some(node) => {
331+
let node = Rc::clone(node);
332+
node.borrow_mut().value = value;
333+
self.remove(&node);
334+
self.push_front(&node);
335+
}
336+
None => {
337+
let node = Rc::new(RefCell::new(Node::new(key, value)));
338+
self.cache.insert(key, Rc::clone(&node));
339+
self.push_front(&node);
340+
if self.cache.len() > self.capacity {
341+
let back_key = self.pop_back().unwrap().borrow().key;
342+
self.cache.remove(&back_key);
336343
}
337344
}
338-
}
345+
};
339346
}
340347

341348
fn push_front(&mut self, node: &Rc<RefCell<Node>>) {
342-
let mut node_borrow_mut = node.borrow_mut();
343-
if let Some(head) = self.head.take() {
344-
head.borrow_mut().prev = Some(Rc::clone(node));
345-
node_borrow_mut.next = Some(head);
346-
node_borrow_mut.prev = None;
347-
self.head = Some(Rc::clone(node));
348-
} else {
349-
self.head = Some(Rc::clone(node));
350-
self.tail = Some(Rc::clone(node));
351-
}
349+
match self.head.take() {
350+
Some(head) => {
351+
head.borrow_mut().prev = Some(Rc::clone(node));
352+
node.borrow_mut().prev = None;
353+
node.borrow_mut().next = Some(head);
354+
self.head = Some(Rc::clone(node));
355+
}
356+
None => {
357+
self.head = Some(Rc::clone(node));
358+
self.tail = Some(Rc::clone(node));
359+
}
360+
};
352361
}
353362

354363
fn remove(&mut self, node: &Rc<RefCell<Node>>) {
@@ -369,27 +378,26 @@ impl LRUCache {
369378
next.borrow_mut().prev = Some(Rc::clone(prev));
370379
prev.borrow_mut().next = Some(Rc::clone(next));
371380
}
372-
}
381+
};
373382
}
374383

375384
fn pop_back(&mut self) -> Option<Rc<RefCell<Node>>> {
376-
if let Some(tail) = self.tail.take() {
377-
match tail.borrow().prev.as_ref() {
378-
Some(prev) => {
379-
prev.borrow_mut().next = None;
380-
self.tail = Some(Rc::clone(prev));
381-
}
382-
None => {
383-
self.head = None;
384-
self.tail = None;
385-
}
385+
match self.tail.take() {
386+
Some(tail) => {
387+
self.remove(&tail);
388+
Some(tail)
386389
}
387-
Some(tail)
388-
} else {
389-
None
390+
None => None,
390391
}
391392
}
392393
}
394+
395+
/**
396+
* Your LRUCache object will be instantiated and called as such:
397+
* let obj = LRUCache::new(capacity);
398+
* let ret_1: i32 = obj.get(key);
399+
* obj.put(key, value);
400+
*/
393401
```
394402

395403
### **Go**

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

+57-49
Original file line numberDiff line numberDiff line change
@@ -218,7 +218,7 @@ class LRUCache {
218218

219219
```rust
220220
use std::cell::RefCell;
221-
use std::collections::hash_map::HashMap;
221+
use std::collections::HashMap;
222222
use std::rc::Rc;
223223

224224
struct Node {
@@ -230,8 +230,8 @@ struct Node {
230230

231231
impl Node {
232232
#[inline]
233-
fn new(key: i32, value: i32) -> Node {
234-
Node {
233+
fn new(key: i32, value: i32) -> Self {
234+
Self {
235235
key,
236236
value,
237237
prev: None,
@@ -247,9 +247,13 @@ struct LRUCache {
247247
tail: Option<Rc<RefCell<Node>>>,
248248
}
249249

250+
/**
251+
* `&self` means the method takes an immutable reference.
252+
* If you need a mutable reference, change it to `&mut self` instead.
253+
*/
250254
impl LRUCache {
251255
fn new(capacity: i32) -> Self {
252-
LRUCache {
256+
Self {
253257
capacity: capacity as usize,
254258
cache: HashMap::new(),
255259
head: None,
@@ -258,46 +262,51 @@ impl LRUCache {
258262
}
259263

260264
fn get(&mut self, key: i32) -> i32 {
261-
if let Some(node) = self.cache.get(&key) {
262-
let node = Rc::clone(node);
263-
self.remove(&node);
264-
self.push_front(&node);
265-
let value = node.borrow().value;
266-
value
267-
} else {
268-
-1
265+
match self.cache.get(&key) {
266+
Some(node) => {
267+
let node = Rc::clone(node);
268+
self.remove(&node);
269+
self.push_front(&node);
270+
let value = node.borrow().value;
271+
value
272+
}
273+
None => -1,
269274
}
270275
}
271276

272277
fn put(&mut self, key: i32, value: i32) {
273-
if let Some(node) = self.cache.get(&key) {
274-
let node = Rc::clone(node);
275-
node.borrow_mut().value = value;
276-
self.remove(&node);
277-
self.push_front(&node);
278-
} else {
279-
let node = Rc::new(RefCell::new(Node::new(key, value)));
280-
self.cache.insert(key, Rc::clone(&node));
281-
self.push_front(&node);
282-
if self.cache.len() > self.capacity {
283-
if let Some(back) = self.pop_back() {
284-
self.cache.remove(&back.borrow().key);
278+
match self.cache.get(&key) {
279+
Some(node) => {
280+
let node = Rc::clone(node);
281+
node.borrow_mut().value = value;
282+
self.remove(&node);
283+
self.push_front(&node);
284+
}
285+
None => {
286+
let node = Rc::new(RefCell::new(Node::new(key, value)));
287+
self.cache.insert(key, Rc::clone(&node));
288+
self.push_front(&node);
289+
if self.cache.len() > self.capacity {
290+
let back_key = self.pop_back().unwrap().borrow().key;
291+
self.cache.remove(&back_key);
285292
}
286293
}
287-
}
294+
};
288295
}
289296

290297
fn push_front(&mut self, node: &Rc<RefCell<Node>>) {
291-
let mut node_borrow_mut = node.borrow_mut();
292-
if let Some(head) = self.head.take() {
293-
head.borrow_mut().prev = Some(Rc::clone(node));
294-
node_borrow_mut.next = Some(head);
295-
node_borrow_mut.prev = None;
296-
self.head = Some(Rc::clone(node));
297-
} else {
298-
self.head = Some(Rc::clone(node));
299-
self.tail = Some(Rc::clone(node));
300-
}
298+
match self.head.take() {
299+
Some(head) => {
300+
head.borrow_mut().prev = Some(Rc::clone(node));
301+
node.borrow_mut().prev = None;
302+
node.borrow_mut().next = Some(head);
303+
self.head = Some(Rc::clone(node));
304+
}
305+
None => {
306+
self.head = Some(Rc::clone(node));
307+
self.tail = Some(Rc::clone(node));
308+
}
309+
};
301310
}
302311

303312
fn remove(&mut self, node: &Rc<RefCell<Node>>) {
@@ -318,27 +327,26 @@ impl LRUCache {
318327
next.borrow_mut().prev = Some(Rc::clone(prev));
319328
prev.borrow_mut().next = Some(Rc::clone(next));
320329
}
321-
}
330+
};
322331
}
323332

324333
fn pop_back(&mut self) -> Option<Rc<RefCell<Node>>> {
325-
if let Some(tail) = self.tail.take() {
326-
match tail.borrow().prev.as_ref() {
327-
Some(prev) => {
328-
prev.borrow_mut().next = None;
329-
self.tail = Some(Rc::clone(prev));
330-
}
331-
None => {
332-
self.head = None;
333-
self.tail = None;
334-
}
334+
match self.tail.take() {
335+
Some(tail) => {
336+
self.remove(&tail);
337+
Some(tail)
335338
}
336-
Some(tail)
337-
} else {
338-
None
339+
None => None,
339340
}
340341
}
341342
}
343+
344+
/**
345+
* Your LRUCache object will be instantiated and called as such:
346+
* let obj = LRUCache::new(capacity);
347+
* let ret_1: i32 = obj.get(key);
348+
* obj.put(key, value);
349+
*/
342350
```
343351

344352
### **Go**

0 commit comments

Comments
 (0)