feat: add solutions to lc problems: No.0217,0232,0380

- No.0217.Contains Duplicate
- No.0232.Implement Queue using Stacks
- No.0380.Insert Delete GetRandom O(1)

Author: YangFong

solution/0200-0299/0217.Contains Duplicate/README.md

@@ -41,6 +41,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：排序**
+
+排序数组，然后两个相邻元素是否相同即可。
+
+**方法二：哈希表**
+
+遍历元素并记录，当第二次出现时，直接返回 `true`。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -135,6 +143,32 @@ var containsDuplicate = function (nums) {
 };
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashSet;
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn contains_duplicate(mut nums: Vec<i32>) -> bool {
+        nums.sort();
+        let n = nums.len();
+        for i in 1..n {
+            if nums[i - 1] == nums[i] {
+                return true
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0217.Contains Duplicate/README_EN.md

@@ -117,6 +117,32 @@ var containsDuplicate = function (nums) {
 };
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashSet;
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn contains_duplicate(mut nums: Vec<i32>) -> bool {
+        nums.sort();
+        let n = nums.len();
+        for i in 1..n {
+            if nums[i - 1] == nums[i] {
+                return true
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0217.Contains Duplicate/Solution.rs

@@ -0,0 +1,6 @@
+use std::collections::HashSet;
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
+    }
+}

solution/0200-0299/0232.Implement Queue using Stacks/README.md

@@ -237,6 +237,70 @@ class MyQueue {
  */
 ```
 
+### **Rust**
+
+```rust
+struct MyQueue {
+    in_stack: Vec<i32>,
+    out_stack: Vec<i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MyQueue {
+
+    fn new() -> Self {
+        Self {
+            in_stack: vec![],
+            out_stack: vec![],
+        }
+    }
+
+    fn push(&mut self, x: i32) {
+        self.in_stack.push(x);
+    }
+
+    fn pop(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        self.out_stack.pop().unwrap()
+    }
+
+    fn peek(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        *self.out_stack.last().unwrap()
+    }
+
+    fn empty(&self) -> bool {
+        self.in_stack.is_empty() && self.out_stack.is_empty()
+    }
+
+    fn fill_out(&mut self){
+        let MyQueue { in_stack, out_stack } = self;
+        if out_stack.is_empty() {
+            while !in_stack.is_empty() {
+                out_stack.push(in_stack.pop().unwrap());
+            }
+        }
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * let obj = MyQueue::new();
+ * obj.push(x);
+ * let ret_2: i32 = obj.pop();
+ * let ret_3: i32 = obj.peek();
+ * let ret_4: bool = obj.empty();
+ */
+```
+
 ### **...**
 
 ```

solution/0200-0299/0232.Implement Queue using Stacks/README_EN.md

@@ -219,6 +219,70 @@ class MyQueue {
  */
 ```
 
+### **Rust**
+
+```rust
+struct MyQueue {
+    in_stack: Vec<i32>,
+    out_stack: Vec<i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MyQueue {
+
+    fn new() -> Self {
+        Self {
+            in_stack: vec![],
+            out_stack: vec![],
+        }
+    }
+
+    fn push(&mut self, x: i32) {
+        self.in_stack.push(x);
+    }
+
+    fn pop(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        self.out_stack.pop().unwrap()
+    }
+
+    fn peek(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        *self.out_stack.last().unwrap()
+    }
+
+    fn empty(&self) -> bool {
+        self.in_stack.is_empty() && self.out_stack.is_empty()
+    }
+
+    fn fill_out(&mut self){
+        let MyQueue { in_stack, out_stack } = self;
+        if out_stack.is_empty() {
+            while !in_stack.is_empty() {
+                out_stack.push(in_stack.pop().unwrap());
+            }
+        }
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * let obj = MyQueue::new();
+ * obj.push(x);
+ * let ret_2: i32 = obj.pop();
+ * let ret_3: i32 = obj.peek();
+ * let ret_4: bool = obj.empty();
+ */
+```
+
 ### **...**
 
 ```

solution/0200-0299/0232.Implement Queue using Stacks/Solution.rs

@@ -0,0 +1,59 @@
+struct MyQueue {
+    in_stack: Vec<i32>,
+    out_stack: Vec<i32>,
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MyQueue {
+
+    fn new() -> Self {
+        Self {
+            in_stack: vec![],
+            out_stack: vec![],
+        }
+    }
+
+    fn push(&mut self, x: i32) {
+        self.in_stack.push(x);
+    }
+
+    fn pop(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        self.out_stack.pop().unwrap()
+    }
+
+    fn peek(&mut self) -> i32 {
+        if self.out_stack.is_empty() {
+            self.fill_out();
+        }
+        *self.out_stack.last().unwrap()
+    }
+
+    fn empty(&self) -> bool {
+        self.in_stack.is_empty() && self.out_stack.is_empty()
+    }
+
+    fn fill_out(&mut self){
+        let MyQueue { in_stack, out_stack } = self;
+        if out_stack.is_empty() {
+            while !in_stack.is_empty() {
+                out_stack.push(in_stack.pop().unwrap());
+            }
+        }
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * let obj = MyQueue::new();
+ * obj.push(x);
+ * let ret_2: i32 = obj.pop();
+ * let ret_3: i32 = obj.peek();
+ * let ret_4: bool = obj.empty();
+ */