feat: add rust solution to lc problem: No.0281 (#1302)

Author: xzhseh

solution/0200-0299/0281.Zigzag Iterator/README.md

@@ -74,6 +74,64 @@ class ZigzagIterator:
 # while i.hasNext(): v.append(i.next())
 ```
 
+### **Rust**
+
+```rust
+struct ZigzagIterator {
+    v1: Vec<i32>,
+    v2: Vec<i32>,
+    /// `false` represents `v1`, `true` represents `v2`
+    flag: bool,
+}
+
+impl ZigzagIterator {
+    fn new(v1: Vec<i32>, v2: Vec<i32>) -> Self {
+        Self {
+            v1,
+            v2,
+            // Initially beginning with `v1`
+            flag: false,
+        }
+    }
+
+    fn next(&mut self) -> i32 {
+        if !self.flag {
+            // v1
+            if self.v1.is_empty() && !self.v2.is_empty() {
+                self.flag = true;
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            if self.v2.is_empty() {
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            let ret = self.v1.remove(0);
+            self.flag = true;
+            return ret;
+        }  else {
+            // v2
+            if self.v2.is_empty() && !self.v1.is_empty() {
+                self.flag = false;
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            if self.v1.is_empty() {
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            let ret = self.v2.remove(0);
+            self.flag = false;
+            return ret;
+        }
+    }
+
+    fn has_next(&self) -> bool {
+        !self.v1.is_empty() || !self.v2.is_empty()
+    }
+}
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->

solution/0200-0299/0281.Zigzag Iterator/README_EN.md

@@ -96,6 +96,64 @@ class ZigzagIterator:
 # while i.hasNext(): v.append(i.next())
 ```
 
+### **Rust**
+
+```rust
+struct ZigzagIterator {
+    v1: Vec<i32>,
+    v2: Vec<i32>,
+    /// `false` represents `v1`, `true` represents `v2`
+    flag: bool,
+}
+
+impl ZigzagIterator {
+    fn new(v1: Vec<i32>, v2: Vec<i32>) -> Self {
+        Self {
+            v1,
+            v2,
+            // Initially beginning with `v1`
+            flag: false,
+        }
+    }
+
+    fn next(&mut self) -> i32 {
+        if !self.flag {
+            // v1
+            if self.v1.is_empty() && !self.v2.is_empty() {
+                self.flag = true;
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            if self.v2.is_empty() {
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            let ret = self.v1.remove(0);
+            self.flag = true;
+            return ret;
+        }  else {
+            // v2
+            if self.v2.is_empty() && !self.v1.is_empty() {
+                self.flag = false;
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            if self.v1.is_empty() {
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            let ret = self.v2.remove(0);
+            self.flag = false;
+            return ret;
+        }
+    }
+
+    fn has_next(&self) -> bool {
+        !self.v1.is_empty() || !self.v2.is_empty()
+    }
+}
+```
+
 ### **Java**
 
 ```java

solution/0200-0299/0281.Zigzag Iterator/Solution.rs

@@ -0,0 +1,53 @@
+struct ZigzagIterator {
+    v1: Vec<i32>,
+    v2: Vec<i32>,
+    /// `false` represents `v1`, `true` represents `v2`
+    flag: bool,
+}
+
+impl ZigzagIterator {
+    fn new(v1: Vec<i32>, v2: Vec<i32>) -> Self {
+        Self {
+            v1,
+            v2,
+            // Initially beginning with `v1`
+            flag: false,
+        }
+    }
+
+    fn next(&mut self) -> i32 {
+        if !self.flag {
+            // v1
+            if self.v1.is_empty() && !self.v2.is_empty() {
+                self.flag = true;
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            if self.v2.is_empty() {
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            let ret = self.v1.remove(0);
+            self.flag = true;
+            return ret;
+        }  else {
+            // v2
+            if self.v2.is_empty() && !self.v1.is_empty() {
+                self.flag = false;
+                let ret = self.v1.remove(0);
+                return ret;
+            }
+            if self.v1.is_empty() {
+                let ret = self.v2.remove(0);
+                return ret;
+            }
+            let ret = self.v2.remove(0);
+            self.flag = false;
+            return ret;
+        }
+    }
+
+    fn has_next(&self) -> bool {
+        !self.v1.is_empty() || !self.v2.is_empty()
+    }
+}