Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit b4c1b21

Browse files
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

Lines changed: 57 additions & 49 deletions
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

Lines changed: 57 additions & 49 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /