88 merge sorted array

Cargo.toml

@@ -7,4 +7,5 @@ members = [
     "binary_tree_postorder_traversal",
     "two_sum",
     "implement_queue_using_stacks",
+    "merge_sorted_array",
 ]

README.md

@@ -10,6 +10,7 @@ Resolving problems of LeetCode in RustLang.
 * [1. Two Sum](./two_sum/src/lib.rs)
 * [7. Reverse Integer](./reverse_integer/src/lib.rs)
 * [15. 3 Sum](./three_sum/src/lib.rs)
+* [88. Merge Sorted Array](./merge_sorted_array/src/lib.rs)
 * [145. Binary Tree Postorder Traversal](./binary_tree_postorder_traversal/src/lib.rs)
 * [215. Kth Largest Element in an Array](./kth_largest/src/lib.rs)
 * [232. Implement Queue using Stacks](./implement_queue_using_stacks/src/lib.rs)

merge_sorted_array/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "merge_sorted_array"
+version = "0.1.0"
+authors = ["Ryan Li <conbas2019@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

merge_sorted_array/src/lib.rs

@@ -0,0 +1,81 @@
+/*!
+ * 88. Merge Sorted Array
+ *
+ * * [Problem link](https://leetcode.com/problems/merge-sorted-array/)
+ */
+
+#![allow(dead_code)]
+
+struct Solution {}
+
+// ----------------------------------------------------------------------------
+
+impl Solution {
+    pub fn merge(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) {
+        let (mut i, mut length) = (0 as usize, m as usize);
+        let mut j = 0 as usize;
+        while j < n as usize {
+            let n2 = nums2[j];
+            if i >= length {
+                // if all numbers in nums1 spent
+                nums1[i] = n2;
+                i += 1;
+                length += 1;
+                j += 1;
+                continue;
+            }
+            if nums1[i] <= n2 {
+                i += 1;
+            } else {
+                // insert n2
+                let mut k = length;
+                while k > i {
+                    nums1[k] = nums1[k - 1];
+                    k -= 1;
+                }
+                nums1[i] = n2;
+                i += 1;
+                length += 1;
+                j += 1;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_example() {
+        let mut nums1 = vec![1, 2, 3, 0, 0, 0];
+        let m = 3;
+        let mut nums2 = vec![2, 5, 6];
+        let n = 3;
+        Solution::merge(&mut nums1, m, &mut nums2, n);
+        let expected = vec![1, 2, 2, 3, 5, 6];
+        assert_eq!(nums1, expected);
+    }
+
+    #[test]
+    fn test_example2() {
+        let mut nums1 = vec![0];
+        let m = 0;
+        let mut nums2 = vec![1];
+        let n = 1;
+        Solution::merge(&mut nums1, m, &mut nums2, n);
+        let expected = vec![1];
+        assert_eq!(nums1, expected);
+    }
+
+    #[test]
+    fn test_example3() {
+        let mut nums1 = vec![2, 0];
+        let m = 1;
+        let mut nums2 = vec![1];
+        let n = 1;
+        Solution::merge(&mut nums1, m, &mut nums2, n);
+        let expected = vec![1, 2];
+        assert_eq!(nums1, expected);
+    }
+}