0002

Author: ruoru

Algorithms/0002.add_two_numbers/ListNode.rs

@@ -0,0 +1,16 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Debug)]
+pub struct ListNode {
+  pub val: i32,
+  pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+  #[inline]
+  fn new(val: i32) -> Self {
+    ListNode {
+      next: None,
+      val
+    }
+  }
+}

Algorithms/0002.add_two_numbers/add_two_numbers.rs

@@ -2,108 +2,28 @@
 use std::collections::LinkedList;
 use std::cmp;
 
-// Definition for singly-linked list.
-// #[derive(PartialEq, Eq, Debug)]
-// pub struct ListNode {
-//   pub val: i32,
-//   pub next: Option<Box<ListNode>>
-// }
-// 
-// impl ListNode {
-//   #[inline]
-//   fn new(val: i32) -> Self {
-//     ListNode {
-//       next: None,
-//       val
-//     }
-//   }
-// }
-
-// impl Solution {
-//     pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
-//         let mut results: LinkedList<u32> = LinkedList::new();
-
-//         let length = cmp::max(list1.len(), list2.len()) + 1;
-//         let mut iter1 = list1.iter();
-//         let mut iter2 = list2.iter();
-
-//         let mut overflow_value: u32 = 0;
-
-//         for _i in 0..length {
-//             let i1 = iter1.next();
-//             let i2 = iter2.next();
-            
-//             let mut v1 = 0;
-//             let mut v2 = 0;
-
-//             if i1.is_some() {
-//                 v1 = *i1.unwrap();
-//             }
-//             if i2.is_some() {
-//                 v2 = *i2.unwrap();
-//             }
-
-//             let mut v = v1 + v2 + overflow_value;
-
-//             overflow_value = v / 10;
-
-//             v = v % 10;
-
-//             results.push_back(v);
-//         }
-
-//         let last_value = results.pop_back();
-//         if last_value.is_some() && last_value.unwrap() != 0 {
-//             results.push_back(last_value.unwrap());
-//         }
-
-//         return results;
-//         }
-// }
 impl Solution {
-pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
-        let mut one = l1.unwrap();
-        let mut two = l2.unwrap();
-        let mut root = ListNode::new(0);
-
-        let mut res = Solution::make_node(one.val + two.val);
-        root.next.get_or_insert(Box::new(res.0));
-
-        let mut curr = &mut root.next;
+    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut results: ListNode::new(0);
+        let mut i1 = l1;
+        let mut i2 = l2;
 
-        while one.next.is_some() || two.next.is_some() {
-            match curr {
-                None => break,
-                Some(now) => {
-                    one = one.next.or(Some(Box::new(ListNode::new(0)))).unwrap();
-                    two = two.next.or(Some(Box::new(ListNode::new(0)))).unwrap();
+        let mut overfalow_value: i32 = 0;
 
-                    res = Solution::make_node(one.val + two.val + res.1);
+        while i1.is_some() || i2.is_some() {
+            let mut v1 = i1.unwrap_or(0);
+            let mut v2 = i2.unwrap_or(0);
 
-                    now.next.get_or_insert(Box::new(res.0));
-                    curr = &mut now.next;
-                }
-            }
-        }
-
-        if res.1 > 0 {
-            if let Some(now) = curr {
-                now.next.get_or_insert(Box::new(ListNode::new(res.1)));
-            }
-        }
+            let mut v = v1 + v2 + overflow_value;
+            overflow_value = v / 10;
+            v = v % 10;
 
-        root.next
-    }
+            results.next.push_back(Some(Box::new(ListNode::new(v))));
 
-    fn make_node(mut result: i32) -> (ListNode, i32) {
-        let single;
-        if result > 9 {
-            single = 1;
-            result = result - 10;
-        } else {
-            single = 0;
+            i1 = iter1.next;
+            i2 = iter2.next;
         }
-        (ListNode::new(result), single)
+        return results;
     }
 }
 

Algorithms/0002.add_two_numbers/add_two_numbers_test.rs

@@ -1,4 +1,5 @@
 mod add_two_numbers;
+mod ListNode;
 use add_two_numbers::Solution;
 
 fn main() {
@@ -14,6 +15,6 @@ fn main() {
     list2.push_back(5);
     list2.push_back(5);
 
-    let results = add_two_numbers(list1, list2);
+    let results = Solution.add_two_numbers(list1, list2);
     println!("{:?}", results);
 }