add linklist macron and q876

Author: OhBonsai

aaa_macro/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "aaa_macro"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

aaa_macro/src/lib.rs

@@ -0,0 +1,36 @@
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+    pub fn new(val: i32) -> ListNode {
+        ListNode {
+            val,
+            next: None
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! linklist {
+    () => {
+        None
+    };
+    ($($e:expr), *) => {
+        {
+            let mut head = Box::new(ListNode::new(0));
+            let mut ref_head = &mut head;
+
+            $(
+            ref_head.next = Some(Box::new(ListNode::new($e)));
+            ref_head = ref_head.next.as_mut().unwrap();
+            )*
+
+            let _ = ref_head; // 避免 `unused_assignments`
+            head.next
+        }
+    };
+}

double-pointer/Cargo.toml

@@ -6,3 +6,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+aaa_macro = {path="../aaa_macro"}

double-pointer/src/lib.rs

@@ -1,5 +1,8 @@
+use aaa_macro::*;
+
 mod q977;
 mod q283;
 mod q167;
 mod q344;
-mod q557;
+mod q557;
+mod q876;

double-pointer/src/q557.rs

@@ -1,29 +1,30 @@
-struct Solution ();
+struct Solution();
+
 impl Solution {
     pub fn reverse_words(s: String) -> String {
-
         let mut v = s.into_bytes();
-        let (mut left, mut right) = (0, 0);
+        let (mut l, mut r) = (0, 0);
+
 
-        while right < v.len() {
-            while right < v.len() && v[right] != ' ' as u8 {
-                right += 1
+        while r < v.len() {
+            while r < v.len() && v[r] != ' ' as u8   {
+                r += 1;
             }
 
-            let next = right + 1;
+            let new_pos = r + 1;
 
-            while left < right {
+            while l < r {
                 unsafe {
-                    std::ptr::swap(&mut v[right -1], &mut v[left]);
+                    std::ptr::swap(&mut v[l], &mut v[r-1]);
+                    l += 1;
+                    r -= 1;
                 }
-                left += 1;
-                right -= 1;
             }
 
-            left = next;
-            right = next;
-        }
 
+            l = new_pos;
+            r = new_pos;
+        }
         String::from_utf8(v).unwrap()
     }
 }
@@ -32,14 +33,10 @@ impl Solution {
 mod tests {
     use super::*;
 
-    #[test] fn test_1() {
-
-
-
+    #[test]
+    fn test_1() {
         assert_eq!(
             Solution::reverse_words(String::from("Let's take LeetCode contest")),
             String::from("s'teL ekat edoCteeL tsetnoc"))
     }
-
-
 }

double-pointer/src/q876.py

@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+import pytest
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def middleNode(self, head: ListNode) -> ListNode:
+        if head.next is None:
+            return head
+
+        fp = head
+        np = head
+
+        while True:
+            np = np.next
+            if np is None:
+                return fp
+            np = np.next
+            if np is None:
+                return fp.next
+
+            fp = fp.next
+
+
+
+def test_mid():
+    head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5, None)))))
+
+    assert Solution().middleNode(head).val == 3
+
+    head = ListNode(0, head)
+    assert Solution().middleNode(head).val == 3
+
+
+if __name__ == '__main__':
+    pytest.main(["./q876.py", "-s", "-v"])

double-pointer/src/q876.rs

@@ -0,0 +1,36 @@
+use super::*;
+
+struct Solution ();
+impl Solution {
+    pub fn middle_node(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut fast = head.as_ref().unwrap();
+        let mut slow = head.as_ref();
+
+        if fast.next.is_none() { return head; }
+
+        while !fast.next.is_none() && !fast.next.as_ref().unwrap().next.is_none() {
+            fast = fast.next.as_ref().unwrap().next.as_ref().unwrap();
+            if fast.next.is_none() {
+                return slow.unwrap().next.clone();
+            }
+            slow = slow.unwrap().next.as_ref();
+
+        }
+        slow.unwrap().next.clone()
+
+
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test] fn test_1() {
+      assert_eq!(Solution::middle_node(linklist!(1,2,3,4,5)).unwrap().val, 3);
+      assert_eq!(Solution::middle_node(linklist!(1,2,3,4,5, 6)).unwrap().val, 4);
+
+
+  }
+}