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 480025a

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

Lines changed: 132 additions & 5 deletions
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‎

Lines changed: 132 additions & 5 deletions
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)

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