[yapp][mand2] solve rest problems

- [x] Reverse Linked List
- [x] Merge Two Sorted Lists
- [x] Linked List Cycle
- [x] Invert Binary Tree

Author: mand2

invert-binary-tree/mand2.md

@@ -0,0 +1,37 @@
+### Intuition
+- 재귀호출
+
+### Approach
+- 재귀 호출
+- 마지막에 left<>right 이동
+
+### Complexity
+- Time complexity: O(n)
+- Space complexity: O(n)
+
+
+# Code
+
+```python
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root:
+            return None
+
+        left = self.invertTree(root.left)
+        right = self.invertTree(root.right)
+
+        root.left = right
+        root.right = left
+        
+        return root
+
+        
+```

linked-list-cycle/mand2.md

@@ -0,0 +1,36 @@
+### Intuition
+
+### Approach
+- pos 는 입력값이 아니다.
+- 계속 회전하므로(detour), 언젠가는 one_way 로 가는 값과 만나게 됨.
+
+### Complexity
+- Time complexity: O(n)
+- Space complexity: O(1)
+
+
+### Code
+
+```python
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        if not head or not head.next:
+            return False
+
+        one_way = head
+        detour = head.next
+
+        while detour and detour.next:
+            if one_way == detour:
+                return True
+            one_way = one_way.next
+            detour = detour.next.next
+
+        return False
+```

merge-two-sorted-lists/mand2.md

@@ -0,0 +1,41 @@
+### Intuition
+
+### Approach
+
+### Complexity
+- Time complexity: O(n)
+- Space complexity: O(1)
+
+### Code
+
+```python
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def mergeTwoLists(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        if not l1:
+            return l2
+        if not l2:
+            return l1
+        
+        merged_list = ListNode()
+        current = merged_list
+
+        while l1 and l2:
+            if l1.val <= l2.val:
+                current.next = l1
+                l1 = l1.next
+            else:
+                current.next = l2
+                l2 = l2.next
+        
+            current = current.next # pointer setting.
+
+        current.next = l1 if l1 else l2
+
+        return merged_list.next
+```

reverse-linked-list/mand2.md

@@ -0,0 +1,37 @@
+### Intuition
+- 투 포인터 (prev, curr)
+
+### Approach
+- 투 포인터
+- 포인터를 이동하기 전에 prev 가 가리키는 (.next) 를 reverse 해 주어야 한다.
+
+### Complexity
+- Time complexity: O(n)
+- Space complexity: O(1)
+
+
+### Code
+
+```python
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head:
+            return head
+
+        prev, curr = None, head
+        
+        while curr:
+            next_node = curr.next
+            curr.next = prev
+            prev = curr
+            curr = next_node
+        
+        return prev
+        
+```