Add 206. Reverse Linked List.md

206. Reverse Linked List.md

@@ -0,0 +1,269 @@
+# step 1
+stackを用いるものと、そのままリストを辿っていくものを思いついたので実装した。
+再帰でもできるが、nodeの最大数（5000）がpythonのrecursion limit（1000）を超えるので、
+実装はしなかった。
+
+stackを用いるもの
+
+「stackの末尾からノードを取ってきて、後ろに繋いでいけば逆順になります」はわかりやすいと思う。
+
+nodeという変数を二つのwhile文で使い回してしまっているのが若干気持ち悪い。
+stackにノードを入れるときと、ノードを取り出すときとで、どちらも今注目しているノードくらいの意味で
+nodeという変数を使っているため、これくらいなら許容範囲かと判断した。後半のwhile文ではnodeはなくても良いかも。
+
+- time complexity: O(n)
+- space complexity: O(n) (auxiliary space: O(n))
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        stack = [None]
+        node = head
+        while node is not None:
+            stack.append(node)
+            node = node.next
+
+        dummy_head = ListNode()
+        tail = dummy_head
+        while stack:
+            node = stack[-1]
+            stack.pop()
+
+            tail.next = node
+            tail = tail.next
+        return dummy_head.next
+```
+
+そのままリストを辿る解法
+
+- time complexity: O(n)
+- space complexity: O(n) (auxiliary space: O(1))
+
+previousを返すのが少し気持ち悪い。nodeに注目していたのに、返すものがpreviousであることに不整合を感じる。
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        previous = None
+        node = head
+        while node is not None:
+            next_node = node.next
+
+            node.next = previous
+            previous = node
+            node = next_node
+
+        return previous
+```
+# step 2
+- https://github.com/katataku/leetcode/pull/7/files
+    - 再帰の解法が書かれている
+        - 後ろからひっくり返していく解法(現在注目しているlistの先頭を引数に取り、そのリストを逆順にしたリストの先頭と末尾を返す)
+        - 先頭ノードを付け替えていく解法(現在注目しているlistの先頭と、逆順にしたlistのheadを引数に取り、オリジナルの先頭を逆順にしているリストの先頭にくっつける解法)
+- https://github.com/konnysh/arai60/pull/7
+    - previous, nextの命名に関して、前後というのは作業者が見ているものに対しての相対的な位置でしかなく、真にその変数が持つ性質を反映したものではない。その変数に何を期待するかを命名に入れた方がいい。previousだったら「構築してるノードの先頭」で、nextは「未処理ノードの先頭」みたいな感じ。そうすればstep1でpreviousを返すという違和感を解消できる。
+
+
+Iterative solution without stack
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        reversed_head = None
+        node = head
+
+        while node is not None:
+            next_node = node.next
+            node.next = reversed_head
+            reversed_head = node
+            node = next_node
+
+        return reversed_head
+```
+
+Iterative solution with stack
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        stack = [None]
+        node = head
+        while node is not None:
+            stack.append(node)
+            node = node.next
+
+        reversed_dummy_head = ListNode()
+        reversed_tail = reversed_dummy_head
+        while stack:
+            node = stack[-1]
+            stack.pop()
+
+            reversed_tail.next = node
+            reversed_tail = reversed_tail.next
+        return reversed_dummy_head.next
+```
+
+Reversive solution (後ろからひっくり返す)
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        def reverse_list_helper(
+            head: ListNode | None
+        ) -> Tuple[ListNode | None, ListNode | None]:
+            if head is None:
+                return None, None
+            if head.next is None:
+                return head, head
+
+            reversed_head, reversed_tail = reverse_list_helper(head.next)
+            reversed_tail.next = head
+
+            reversed_tail = reversed_tail.next
+            reversed_tail.next = None
+            return reversed_head, reversed_tail
+        return reverse_list_helper(head)[0]
+```
+
+Recursive solution (先頭ノードを付け替える)
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        def reverse_list_helper(
+            head: ListNode | None,
+            reversed_head: ListNode | None) -> ListNode | None:
+            if head is None:
+                return reversed_head
+            next_head = head.next
+            head.next = reversed_head
+            reversed_head = head
+            return reverse_list_helper(next_head, reversed_head)
+        return reverse_list_helper(head, None)
+```
+
+inner functionのtype annotaionはpython3.10+のものとした。
+public APIとかではないのでつける必要はない気がした。
+
+# step 3
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        reversed_head = None
+        node = head
+        while node is not None:
+            next_node = node.next
+            node.next = reversed_head
+            reversed_head = node
+            node = next_node
+        return reversed_head
+```
+
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        def reverse_list_helper(head):
+            if head is None:
+                return None, None
+            if head.next is None:
+                return head, head
+            reversed_head, reversed_tail = reverse_list_helper(head.next)
+
+            reversed_tail.next = head
+            reversed_tail = reversed_tail.next
+            reversed_tail.next = None
+            return reversed_head, reversed_tail
+        return reverse_list_helper(head)[0]
+```
+
+# step 4
+コメントまとめ
+- 大規模開発ではtype annotationを入れることが多い
+- ListNode | NoneよりOptional[ListNode] のほうがよく見る
+- ループの途中で仕事を引き継いだ時に、パズルとならないような変数名をつける
+
+stackを使う解法
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        stack = []
+        node = head
+        while node is not None:
+            stack.append(node)
+            node = node.next
+
+        dummy_head = ListNode()
+        tail = dummy_head
+        while stack:
+            tail.next = stack.pop()
+            tail = tail.next
+        tail.next = None
+        return dummy_head.next
+```
+
+stackを使わないiterative
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        reversed_head = None
+        node = head
+        while node is not None:
+            next_node = node.next
+            node.next = reversed_head
+            reversed_head = node
+            node = next_node
+        return reversed_head
+```
+
+後ろから作るrecursiveな解法
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        def reverse_list_helper(
+            head: Optional[ListNode]
+        ) -> Tuple[Optional[ListNode], Optional[ListNode]]:
+            if head is None:
+                return None, None
+            if head.next is None:
+                return head, head
+            tail_list = head.next
+            head_node = head
+            head_node.next = None
+
+            reversed_head, reversed_tail = reverse_list_helper(tail_list)
+            reversed_tail.next = head_node
+            reversed_tail = reversed_tail.next
+            return reversed_head, reversed_tail
+        return reverse_list_helper(head)[0]
+```
+
+先頭を付け替えていくrecursiveな解法
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        def reverse_list_helper(
+            head: Optional[ListNode],
+            reversed_head: Optional[ListNode]
+        ) -> Optional[ListNode]:
+            if head is None:
+                return reversed_head
+            tail_list = head.next
+            head.next = reversed_head
+            reversed_head = head
+            return reverse_list_helper(tail_list, reversed_head)
+        return reverse_list_helper(head, None)
+```
+
+stackに積むときにnodeのリンクをバラバラにする
+```python
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        node = head
+        stack = []
+        while node is not None:
+            next_node = node.next
+            node.next = None
+            stack.append(node)
+            node = next_node
+
+        dummy_head = ListNode()
+        node = dummy_head
+        while stack:
+            node.next = stack.pop()
+            node = node.next
+        return dummy_head.next
+```