From 42fb596ac01416f4a32db850222606613979a5fd Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 13 May 2020 20:53:05 +0300
Subject: [PATCH 01/25] +linked-list.md +reverse-linked-list

---
 README.md      |  3 ---
 linked-list.md | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 3 deletions(-)
 delete mode 100644 README.md
 create mode 100644 linked-list.md

diff --git a/README.md b/README.md
deleted file mode 100644
index 7c3b229..0000000
--- a/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Algorithms 2019-2020 Python LEETCODE
-
-Check branches for information.
\ No newline at end of file
diff --git a/linked-list.md b/linked-list.md
new file mode 100644
index 0000000..ea69dbe
--- /dev/null
+++ b/linked-list.md
@@ -0,0 +1,35 @@
+# Linked list
+
+## Reverse linked list
+
+https://leetcode.com/problems/reverse-linked-list/
+
+```python
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution(object):
+    def reverseList(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+
+        if head and head.next:
+            prev = head
+            next = head.next
+            head.next = None
+            head = next
+
+            while (head.next):
+                next = next.next
+                head.next = prev
+                prev = head
+                head = next
+
+            head.next = prev
+        return head
+
+```
\ No newline at end of file

From 080e83306502ec737c9e60ef6cdf5c9819fb529d Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 22 May 2020 19:15:05 +0300
Subject: [PATCH 02/25] Changed variables' name, added hyperlinks (anchors)

---
 linked-list.md | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index ea69dbe..a3ea47e 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -1,5 +1,7 @@
 # Linked list
 
++ [Reverse linked list](#reverse-linked-list)
+
 ## Reverse linked list
 
 https://leetcode.com/problems/reverse-linked-list/
@@ -16,20 +18,20 @@ class Solution(object):
         :type head: ListNode
         :rtype: ListNode
         """
+        currentNode = head
+        if currentNode and currentNode.next:
+            prevNode = currentNode
+            nextNode = currentNode.next
+            currentNode.next = None
+            currentNode = nextNode
 
-        if head and head.next:
-            prev = head
-            next = head.next
-            head.next = None
-            head = next
-
-            while (head.next):
-                next = next.next
-                head.next = prev
-                prev = head
-                head = next
+            while currentNode.next:
+                nextNode = nextNode.next
+                currentNode.next = prevNode
+                prevNode = currentNode
+                currentNode = nextNode
 
-            head.next = prev
-        return head
+            currentNode.next = prevNode
+        return currentNode
 
 ```
\ No newline at end of file

From 0d5a6623490c347ee16f1dc29556a76c7f059ccc Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 22 May 2020 19:22:14 +0300
Subject: [PATCH 03/25] Improved [Reverse linked list]

---
 linked-list.md | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index a3ea47e..cb55b12 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -19,19 +19,14 @@ class Solution(object):
         :rtype: ListNode
         """
         currentNode = head
-        if currentNode and currentNode.next:
-            prevNode = currentNode
+        prevNode = None
+
+        while currentNode:
             nextNode = currentNode.next
-            currentNode.next = None
+            currentNode.next = prevNode
+            prevNode = currentNode
             currentNode = nextNode
 
-            while currentNode.next:
-                nextNode = nextNode.next
-                currentNode.next = prevNode
-                prevNode = currentNode
-                currentNode = nextNode
-
-            currentNode.next = prevNode
-        return currentNode
+        return prevNode
 
 ```
\ No newline at end of file

From 57b19108930dfa4937849b8f266de07d5969ff99 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Mon, 1 Jun 2020 21:35:22 +0300
Subject: [PATCH 04/25] Added LEETCODE middle-of-the-linked-list solution.

---
 linked-list.md | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index cb55b12..f0ef4c0 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -1,10 +1,10 @@
 # Linked list
 
-+ [Reverse linked list](#reverse-linked-list)
++ [Middle of the Linked List](#middle-of-the-linked-list)
 
-## Reverse linked list
+## Middle of the Linked List
 
-https://leetcode.com/problems/reverse-linked-list/
+https://leetcode.com/problems/middle-of-the-linked-list/
 
 ```python
 # Definition for singly-linked list.
@@ -13,20 +13,15 @@ https://leetcode.com/problems/reverse-linked-list/
 #         self.val = val
 #         self.next = next
 class Solution(object):
-    def reverseList(self, head):
+    def middleNode(self, head):
         """
         :type head: ListNode
         :rtype: ListNode
         """
-        currentNode = head
-        prevNode = None
-
-        while currentNode:
-            nextNode = currentNode.next
-            currentNode.next = prevNode
-            prevNode = currentNode
-            currentNode = nextNode
-
-        return prevNode
+        pastNode = nextNode = head
+        while nextNode and nextNode.next:
+            pastNode = pastNode.next
+            nextNode = nextNode.next.next
+        return pastNode
 
 ```
\ No newline at end of file

From 303c7ae0c16ae0782ce00ec5838a2ac70e422cd4 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Mon, 1 Jun 2020 22:31:00 +0300
Subject: [PATCH 05/25] Added LEETCODE palindrome-linked-list solution.

---
 linked-list.md | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index f0ef4c0..df298f4 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -1,10 +1,10 @@
 # Linked list
 
-+ [Middle of the Linked List](#middle-of-the-linked-list)
++ [Palindrome Linked List](#palindrome-linked-list)
 
-## Middle of the Linked List
+## Palindrome Linked List
 
-https://leetcode.com/problems/middle-of-the-linked-list/
+https://leetcode.com/problems/palindrome-linked-list/
 
 ```python
 # Definition for singly-linked list.
@@ -13,15 +13,27 @@ https://leetcode.com/problems/middle-of-the-linked-list/
 #         self.val = val
 #         self.next = next
 class Solution(object):
-    def middleNode(self, head):
+    def isPalindrome(self, head):
         """
         :type head: ListNode
-        :rtype: ListNode
+        :rtype: bool
         """
-        pastNode = nextNode = head
-        while nextNode and nextNode.next:
-            pastNode = pastNode.next
-            nextNode = nextNode.next.next
-        return pastNode
+        mid = tail = head
+        while tail and tail.next:
+            mid = mid.next
+            tail = tail.next.next
+
+        if mid is None:
+            return True
+        if mid.next is None:
+            return head.val == mid.val
+
+        mid.next.next, mid.next, tail, mid = mid, None, mid.next.next, mid.next
+        while tail:
+            tail.next, mid, tail = mid, tail, tail.next
+
+        while mid and head.val == mid.val:
+            head, mid = head.next, mid.next
+        return not mid
 
 ```
\ No newline at end of file

From cbc585fcdc3ed88c070c912ac4b2ca6cee39418f Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Mon, 1 Jun 2020 22:48:34 +0300
Subject: [PATCH 06/25] Added LEETCODE merge-two-sorted-lists solution.

---
 linked-list.md | 34 +++++++++-------------------------
 1 file changed, 9 insertions(+), 25 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index df298f4..f350957 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -1,10 +1,10 @@
 # Linked list
 
-+ [Palindrome Linked List](#palindrome-linked-list)
++ [Merge Two Sorted Lists](#merge-two-sorted-lists)
 
-## Palindrome Linked List
+## Merge Two Sorted Lists
 
-https://leetcode.com/problems/palindrome-linked-list/
+https://leetcode.com/problems/merge-two-sorted-lists/
 
 ```python
 # Definition for singly-linked list.
@@ -13,27 +13,11 @@ https://leetcode.com/problems/palindrome-linked-list/
 #         self.val = val
 #         self.next = next
 class Solution(object):
-    def isPalindrome(self, head):
-        """
-        :type head: ListNode
-        :rtype: bool
-        """
-        mid = tail = head
-        while tail and tail.next:
-            mid = mid.next
-            tail = tail.next.next
-
-        if mid is None:
-            return True
-        if mid.next is None:
-            return head.val == mid.val
-
-        mid.next.next, mid.next, tail, mid = mid, None, mid.next.next, mid.next
-        while tail:
-            tail.next, mid, tail = mid, tail, tail.next
-
-        while mid and head.val == mid.val:
-            head, mid = head.next, mid.next
-        return not mid
+    def mergeTwoLists(self, a, b):
+        if not a or b and a.val > b.val:
+            a, b = b, a
+        if a:
+            a.next = self.mergeTwoLists(a.next, b)
+        return a
 
 ```
\ No newline at end of file

From 07c4497e92021b22788afa49ff61cca8a9d92acb Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 00:52:21 +0300
Subject: [PATCH 07/25] Added LEETCODE Merge Two Sorted Lists (iterative)
 solution.

---
 linked-list.md | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/linked-list.md b/linked-list.md
index f350957..0a314c7 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -1,8 +1,9 @@
 # Linked list
 
-+ [Merge Two Sorted Lists](#merge-two-sorted-lists)
++ [Merge Two Sorted Lists (recursive)](#merge-two-sorted-lists-recursive)
++ [Merge Two Sorted Lists (iterative)](#merge-two-sorted-lists-iterative)
 
-## Merge Two Sorted Lists
+## Merge Two Sorted Lists (recursive)
 
 https://leetcode.com/problems/merge-two-sorted-lists/
 
@@ -20,4 +21,28 @@ class Solution(object):
             a.next = self.mergeTwoLists(a.next, b)
         return a
 
+```
+
+## Merge Two Sorted Lists (iterative)
+
+```python
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution(object):
+    def mergeTwoLists(self, a, b):
+        head = tail = ListNode()
+        while a and b:
+            if a.val < b.val:
+                tail.next = a
+                a = a.next
+            else:
+                tail.next = b
+                b = b.next
+            tail = tail.next
+        tail.next = a or b
+        return head.next
+
 ```
\ No newline at end of file

From 5d394cc134c1c53905cb57aefa8de78d0cedde4e Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 00:55:30 +0300
Subject: [PATCH 08/25] Added a forgotten link for an iterative solution.

---
 linked-list.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/linked-list.md b/linked-list.md
index 0a314c7..6ec28f1 100644
--- a/linked-list.md
+++ b/linked-list.md
@@ -25,6 +25,8 @@ class Solution(object):
 
 ## Merge Two Sorted Lists (iterative)
 
+https://leetcode.com/problems/merge-two-sorted-lists/
+
 ```python
 # Definition for singly-linked list.
 # class ListNode(object):

From f6c5605dce6b3dcdb351ea24e9cc1e15f420fdda Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 02:14:46 +0300
Subject: [PATCH 09/25] Added LEETCODE "binary-tree-inorder-traversal"
 solution.

---
 linked-list.md | 50 --------------------------------------------------
 tree.md        | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 50 deletions(-)
 delete mode 100644 linked-list.md
 create mode 100644 tree.md

diff --git a/linked-list.md b/linked-list.md
deleted file mode 100644
index 6ec28f1..0000000
--- a/linked-list.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Linked list
-
-+ [Merge Two Sorted Lists (recursive)](#merge-two-sorted-lists-recursive)
-+ [Merge Two Sorted Lists (iterative)](#merge-two-sorted-lists-iterative)
-
-## Merge Two Sorted Lists (recursive)
-
-https://leetcode.com/problems/merge-two-sorted-lists/
-
-```python
-# Definition for singly-linked list.
-# class ListNode(object):
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution(object):
-    def mergeTwoLists(self, a, b):
-        if not a or b and a.val > b.val:
-            a, b = b, a
-        if a:
-            a.next = self.mergeTwoLists(a.next, b)
-        return a
-
-```
-
-## Merge Two Sorted Lists (iterative)
-
-https://leetcode.com/problems/merge-two-sorted-lists/
-
-```python
-# Definition for singly-linked list.
-# class ListNode(object):
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution(object):
-    def mergeTwoLists(self, a, b):
-        head = tail = ListNode()
-        while a and b:
-            if a.val < b.val:
-                tail.next = a
-                a = a.next
-            else:
-                tail.next = b
-                b = b.next
-            tail = tail.next
-        tail.next = a or b
-        return head.next
-
-```
\ No newline at end of file
diff --git a/tree.md b/tree.md
new file mode 100644
index 0000000..b1e494c
--- /dev/null
+++ b/tree.md
@@ -0,0 +1,41 @@
+# Binary tree
+
++ [Binary Tree Inorder Traversal](#binary-tree-inorder-traversal)
+
+## Binary Tree Inorder Traversal
+
+https://leetcode.com/problems/binary-tree-inorder-traversal/
+
+```python
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution(object):
+    def inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        head = root
+        inorderlist = []
+        while head:
+            if not head.left:
+                inorderlist.append(head.val)
+                head = head.right
+            elif head.left:
+                curNode = head.left
+                while head.left and curNode.right and curNode.right != head:
+                    curNode = curNode.right
+                if not curNode.right:
+                    curNode.right = head
+                    head = head.left
+                elif curNode.right == head:
+                    inorderlist.append(head.val)
+                    curNode.right = None
+                    head = head.right
+        return inorderlist
+
+```
\ No newline at end of file

From 4101f7eefcd7978d941053b11e348cdc99c83102 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 13:38:03 +0300
Subject: [PATCH 10/25] Added recursive and iterative,stack LEETCODE
 "binary-tree-inorder-traversal" solutions.

---
 tree.md | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 63 insertions(+), 2 deletions(-)

diff --git a/tree.md b/tree.md
index b1e494c..71f0052 100644
--- a/tree.md
+++ b/tree.md
@@ -1,8 +1,10 @@
 # Binary tree
 
-+ [Binary Tree Inorder Traversal](#binary-tree-inorder-traversal)
++ [Binary Tree Inorder Traversal (iterative, threaded)](#binary-tree-inorder-traversal-iterative-threaded)
++ [Binary Tree Inorder Traversal (recursive)](#binary-tree-inorder-traversal-recursive)
++ [Binary Tree Inorder Traversal (iterative, stack)](#binary-tree-inorder-traversal-iterative-stack)
 
-## Binary Tree Inorder Traversal
+## Binary Tree Inorder Traversal (iterative, threaded)
 
 https://leetcode.com/problems/binary-tree-inorder-traversal/
 
@@ -38,4 +40,63 @@ class Solution(object):
                     head = head.right
         return inorderlist
 
+```
+
+## Binary Tree Inorder Traversal (recursive)
+
+https://leetcode.com/problems/binary-tree-inorder-traversal/
+
+```python
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution(object):
+    inorderlist = []
+
+    def inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        head = root
+        return self.inorderTraversal(head.left) + [head.val] + self.inorderTraversal(head.right) if head else []
+
+```
+
+## Binary Tree Inorder Traversal (iterative, stack)
+
+https://leetcode.com/problems/binary-tree-inorder-traversal/
+
+```python
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution(object):
+    inorderlist = []
+
+    def inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        if not root:
+            return []
+        stack = []
+        inorderlist = []
+        while stack or root:
+            if root:
+                stack.append(root)
+                root = root.left
+            else:
+                node = stack.pop()
+                inorderlist.append(node.val)
+                root = node.right
+        return inorderlist
+
 ```
\ No newline at end of file

From 164fd7eafff31372867c541f6df848aad7931370 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 13:39:47 +0300
Subject: [PATCH 11/25] Removed an extra line from recursive solution.

---
 tree.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tree.md b/tree.md
index 71f0052..aa8f9e7 100644
--- a/tree.md
+++ b/tree.md
@@ -78,8 +78,6 @@ https://leetcode.com/problems/binary-tree-inorder-traversal/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    inorderlist = []
-
     def inorderTraversal(self, root):
         """
         :type root: TreeNode

From bee6f14e17035c9a9185cbbd140fc8e2620c9cde Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Tue, 2 Jun 2020 13:41:01 +0300
Subject: [PATCH 12/25] Removed an extra line from recursive solution
 (another).

---
 tree.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tree.md b/tree.md
index aa8f9e7..be41b44 100644
--- a/tree.md
+++ b/tree.md
@@ -54,8 +54,6 @@ https://leetcode.com/problems/binary-tree-inorder-traversal/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    inorderlist = []
-
     def inorderTraversal(self, root):
         """
         :type root: TreeNode

From 07205fc1d829ffe37810bfeb257ccdb8cbf32de1 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:34:16 +0300
Subject: [PATCH 13/25] Added LEETCODE "symmetric-tree" solution with euler
 path.

---
 tree.md | 95 +++++++++------------------------------------------------
 1 file changed, 15 insertions(+), 80 deletions(-)

diff --git a/tree.md b/tree.md
index be41b44..279c14d 100644
--- a/tree.md
+++ b/tree.md
@@ -1,12 +1,10 @@
 # Binary tree
 
-+ [Binary Tree Inorder Traversal (iterative, threaded)](#binary-tree-inorder-traversal-iterative-threaded)
-+ [Binary Tree Inorder Traversal (recursive)](#binary-tree-inorder-traversal-recursive)
-+ [Binary Tree Inorder Traversal (iterative, stack)](#binary-tree-inorder-traversal-iterative-stack)
++ [Symmetric Tree](#symmetric-tree)
 
-## Binary Tree Inorder Traversal (iterative, threaded)
+## Symmetric Tree
 
-https://leetcode.com/problems/binary-tree-inorder-traversal/
+https://leetcode.com/problems/symmetric-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -16,83 +14,20 @@ https://leetcode.com/problems/binary-tree-inorder-traversal/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def inorderTraversal(self, root):
+    def isSymmetric(self, root):
         """
         :type root: TreeNode
-        :rtype: List[int]
+        :rtype: bool
         """
-        head = root
-        inorderlist = []
-        while head:
-            if not head.left:
-                inorderlist.append(head.val)
-                head = head.right
-            elif head.left:
-                curNode = head.left
-                while head.left and curNode.right and curNode.right != head:
-                    curNode = curNode.right
-                if not curNode.right:
-                    curNode.right = head
-                    head = head.left
-                elif curNode.right == head:
-                    inorderlist.append(head.val)
-                    curNode.right = None
-                    head = head.right
-        return inorderlist
-
-```
-
-## Binary Tree Inorder Traversal (recursive)
-
-https://leetcode.com/problems/binary-tree-inorder-traversal/
-
-```python
-# Definition for a binary tree node.
-# class TreeNode(object):
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
-class Solution(object):
-    def inorderTraversal(self, root):
-        """
-        :type root: TreeNode
-        :rtype: List[int]
-        """
-        head = root
-        return self.inorderTraversal(head.left) + [head.val] + self.inorderTraversal(head.right) if head else []
-
-```
-
-## Binary Tree Inorder Traversal (iterative, stack)
-
-https://leetcode.com/problems/binary-tree-inorder-traversal/
-
-```python
-# Definition for a binary tree node.
-# class TreeNode(object):
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
-class Solution(object):
-    def inorderTraversal(self, root):
-        """
-        :type root: TreeNode
-        :rtype: List[int]
-        """
-        if not root:
-            return []
-        stack = []
-        inorderlist = []
-        while stack or root:
-            if root:
-                stack.append(root)
-                root = root.left
-            else:
-                node = stack.pop()
-                inorderlist.append(node.val)
-                root = node.right
-        return inorderlist
+        path = []
+        def euler(node):
+            if not node: path.append(None); return
+            path.append(node.val)
+            euler(node.left)
+            path.append(node.val)
+            euler(node.right)
+            path.append(node.val)
+        euler(root)
+        return path == path[::-1]
 
 ```
\ No newline at end of file

From 0756cfda5321153b098fffd21c542477c94b9e48 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:37:50 +0300
Subject: [PATCH 14/25] Added LEETCODE "maximum-depth-of-binary-tree" solution.

---
 tree.md | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/tree.md b/tree.md
index 279c14d..03a5fdb 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Symmetric Tree](#symmetric-tree)
++ [Maximum Depth of Binary Tree](#maximum-depth-of-binary-tree)
 
-## Symmetric Tree
+## Maximum Depth of Binary Tree
 
-https://leetcode.com/problems/symmetric-tree/
+https://leetcode.com/problems/maximum-depth-of-binary-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,20 +14,12 @@ https://leetcode.com/problems/symmetric-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def isSymmetric(self, root):
+    def maxDepth(self, root):
         """
         :type root: TreeNode
-        :rtype: bool
+        :rtype: int
         """
-        path = []
-        def euler(node):
-            if not node: path.append(None); return
-            path.append(node.val)
-            euler(node.left)
-            path.append(node.val)
-            euler(node.right)
-            path.append(node.val)
-        euler(root)
-        return path == path[::-1]
+        if not root: return 0
+        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
 
 ```
\ No newline at end of file

From 9b155a360724832ad9d4d74d41da3870951c41b6 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:40:14 +0300
Subject: [PATCH 15/25] Added LEETCODE "same-tree" recursive solution.

---
 tree.md | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/tree.md b/tree.md
index 03a5fdb..3cfd7ff 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Maximum Depth of Binary Tree](#maximum-depth-of-binary-tree)
++ [Same Tree](#same-tree)
 
-## Maximum Depth of Binary Tree
+## Same Tree
 
-https://leetcode.com/problems/maximum-depth-of-binary-tree/
+https://leetcode.com/problems/same-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,12 +14,9 @@ https://leetcode.com/problems/maximum-depth-of-binary-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def maxDepth(self, root):
-        """
-        :type root: TreeNode
-        :rtype: int
-        """
-        if not root: return 0
-        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
+    def isSameTree(self, p, q):
+        if p and q:
+            return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
+        return p is q
 
 ```
\ No newline at end of file

From 9f4cb34ee69749a46bbee564d931ef036ca021dc Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:44:53 +0300
Subject: [PATCH 16/25] Added LEETCODE "maximum-depth-of-binary-tree" recursive
 solution.

---
 tree.md | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/tree.md b/tree.md
index 3cfd7ff..03a5fdb 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Same Tree](#same-tree)
++ [Maximum Depth of Binary Tree](#maximum-depth-of-binary-tree)
 
-## Same Tree
+## Maximum Depth of Binary Tree
 
-https://leetcode.com/problems/same-tree/
+https://leetcode.com/problems/maximum-depth-of-binary-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,9 +14,12 @@ https://leetcode.com/problems/same-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def isSameTree(self, p, q):
-        if p and q:
-            return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
-        return p is q
+    def maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root: return 0
+        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
 
 ```
\ No newline at end of file

From e732f703ab6f8a48b3765abea2c90db6b7ad2f53 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:46:08 +0300
Subject: [PATCH 17/25] Added LEETCODE "same-tree" recursive solution.

---
 tree.md | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/tree.md b/tree.md
index 03a5fdb..3cfd7ff 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Maximum Depth of Binary Tree](#maximum-depth-of-binary-tree)
++ [Same Tree](#same-tree)
 
-## Maximum Depth of Binary Tree
+## Same Tree
 
-https://leetcode.com/problems/maximum-depth-of-binary-tree/
+https://leetcode.com/problems/same-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,12 +14,9 @@ https://leetcode.com/problems/maximum-depth-of-binary-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def maxDepth(self, root):
-        """
-        :type root: TreeNode
-        :rtype: int
-        """
-        if not root: return 0
-        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
+    def isSameTree(self, p, q):
+        if p and q:
+            return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
+        return p is q
 
 ```
\ No newline at end of file

From c6f6e52f5c432c0f1f4b2a7c962c53d9c44e2941 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:48:45 +0300
Subject: [PATCH 18/25] Added LEETCODE "invert-binary-tree" recursive solution.

---
 tree.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tree.md b/tree.md
index 3cfd7ff..a396272 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Same Tree](#same-tree)
++ [Invert Binary Tree](#invert-binary-tree)
 
-## Same Tree
+## Invert Binary Tree
 
-https://leetcode.com/problems/same-tree/
+https://leetcode.com/problems/invert-binary-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,9 +14,9 @@ https://leetcode.com/problems/same-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def isSameTree(self, p, q):
-        if p and q:
-            return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
-        return p is q
+    def invertTree(self, root):
+        if root:
+            root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
+            return root
 
 ```
\ No newline at end of file

From c313d6f7fc62cc19ed9a2e299090ea8d3105fce2 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:50:42 +0300
Subject: [PATCH 19/25] Added LEETCODE "path-sum" recursive solution.

---
 tree.md | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/tree.md b/tree.md
index a396272..ce4ccf0 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Invert Binary Tree](#invert-binary-tree)
++ [Path Sum](#path-sum)
 
-## Invert Binary Tree
+## Path Sum
 
-https://leetcode.com/problems/invert-binary-tree/
+https://leetcode.com/problems/path-sum/
 
 ```python
 # Definition for a binary tree node.
@@ -14,9 +14,12 @@ https://leetcode.com/problems/invert-binary-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def invertTree(self, root):
-        if root:
-            root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
-            return root
+    def hasPathSum(self, root, sum):
+        if not root:
+            return False
+        sum -= root.val
+        if not root.left and not root.right:
+            return sum == 0
+        return self.hasPathSum(root.left,sum) or self.hasPathSum(root.right,sum)
 
 ```
\ No newline at end of file

From 06a7d969a21c9313bb80d42e5b1df4c36401effd Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 12:54:10 +0300
Subject: [PATCH 20/25] Added LEETCODE "binary-tree-level-order-traversal"
 recursive solution.

---
 tree.md | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/tree.md b/tree.md
index ce4ccf0..ba03856 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Path Sum](#path-sum)
++ [Binary Tree Level Order Traversal](#binary-tree-level-order-traversal)
 
-## Path Sum
+## Binary Tree Level Order Traversal
 
-https://leetcode.com/problems/path-sum/
+https://leetcode.com/problems/binary-tree-level-order-traversal/
 
 ```python
 # Definition for a binary tree node.
@@ -14,12 +14,18 @@ https://leetcode.com/problems/path-sum/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def hasPathSum(self, root, sum):
+    def levelOrder(self, root):
+        res = []
+        self.dfs(root, 0, res)
+        return res
+    
+    def dfs(self, root, level, res):
         if not root:
-            return False
-        sum -= root.val
-        if not root.left and not root.right:
-            return sum == 0
-        return self.hasPathSum(root.left,sum) or self.hasPathSum(root.right,sum)
+            return 
+        if len(res) < level+1:
+            res.append([])
+        res[level].append(root.val)
+        self.dfs(root.left, level+1, res)
+        self.dfs(root.right, level+1, res)
 
 ```
\ No newline at end of file

From 3a1f0bd32f22b83cf06ab39902c5172bbd5747e7 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Wed, 3 Jun 2020 14:17:27 +0300
Subject: [PATCH 21/25] Added LEETCODE "subtree-of-another-tree" recursive
 solution.

---
 tree.md | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/tree.md b/tree.md
index ba03856..d805315 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Binary Tree Level Order Traversal](#binary-tree-level-order-traversal)
++ [Subtree of Another Tree](#subtree-of-another-tree)
 
-## Binary Tree Level Order Traversal
+## Subtree of Another Tree
 
-https://leetcode.com/problems/binary-tree-level-order-traversal/
+https://leetcode.com/problems/subtree-of-another-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -14,18 +14,12 @@ https://leetcode.com/problems/binary-tree-level-order-traversal/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def levelOrder(self, root):
-        res = []
-        self.dfs(root, 0, res)
-        return res
-    
-    def dfs(self, root, level, res):
-        if not root:
-            return 
-        if len(res) < level+1:
-            res.append([])
-        res[level].append(root.val)
-        self.dfs(root.left, level+1, res)
-        self.dfs(root.right, level+1, res)
+    def isSubtree(self, s, t):
+        def traverse_tree(node):
+            if not node:
+                return None
+            return "#{} {} {}".format(node.val, traverse_tree(node.left), traverse_tree(node.right))
+
+        return traverse_tree(t) in traverse_tree(s)
 
 ```
\ No newline at end of file

From d0be9f6932b353e9805d50e387894bd9b754a55a Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 5 Jun 2020 01:11:37 +0300
Subject: [PATCH 22/25] Added LEETCODE "kth-smallest-element-in-a-bst"
 recursive solution.

---
 tree.md | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/tree.md b/tree.md
index d805315..b167a1a 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Subtree of Another Tree](#subtree-of-another-tree)
++ [Kth Smallest Element in a BST](#kth-smallest-element-in-a-bst)
 
-## Subtree of Another Tree
+## Kth Smallest Element in a BST
 
-https://leetcode.com/problems/subtree-of-another-tree/
+https://leetcode.com/problems/kth-smallest-element-in-a-bst/
 
 ```python
 # Definition for a binary tree node.
@@ -14,12 +14,24 @@ https://leetcode.com/problems/subtree-of-another-tree/
 #         self.left = left
 #         self.right = right
 class Solution(object):
-    def isSubtree(self, s, t):
-        def traverse_tree(node):
-            if not node:
-                return None
-            return "#{} {} {}".format(node.val, traverse_tree(node.left), traverse_tree(node.right))
+    def in_order_traversal(self, root):
+        if not root: return
+        self.in_order_traversal(root.left)
+        self.list.append(root.val)
+        self.in_order_traversal(root.right)
 
-        return traverse_tree(t) in traverse_tree(s)
+    def kthSmallest(self, _root, k):
+        """
+        :type _root: TreeNode
+        :type k: int
+        :rtype: int
+        """
+        root = _root
+        if not root: return 0
+
+        self.list = []
+        self.in_order_traversal(root)
+
+        return self.list[k - 1]
 
 ```
\ No newline at end of file

From a7058f59a58c012de2becd6eb981e1a67f52c53a Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 5 Jun 2020 01:30:50 +0300
Subject: [PATCH 23/25] Added LEETCODE "validate-binary-search-tree" recursive
 solution.

---
 tree.md | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/tree.md b/tree.md
index b167a1a..40e49a9 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Kth Smallest Element in a BST](#kth-smallest-element-in-a-bst)
++ [Validate Binary Search Tree](#validate-binary-search-tree)
 
-## Kth Smallest Element in a BST
+## Validate Binary Search Tree
 
-https://leetcode.com/problems/kth-smallest-element-in-a-bst/
+https://leetcode.com/problems/validate-binary-search-tree/
 
 ```python
 # Definition for a binary tree node.
@@ -13,25 +13,19 @@ https://leetcode.com/problems/kth-smallest-element-in-a-bst/
 #         self.val = val
 #         self.left = left
 #         self.right = right
-class Solution(object):
-    def in_order_traversal(self, root):
-        if not root: return
-        self.in_order_traversal(root.left)
-        self.list.append(root.val)
-        self.in_order_traversal(root.right)
 
-    def kthSmallest(self, _root, k):
+
+class Solution(object):
+    def isValidBST(self, _root, first=True):
         """
         :type _root: TreeNode
-        :type k: int
-        :rtype: int
+        :type first: bool
+        :rtype: bool
         """
         root = _root
-        if not root: return 0
-
-        self.list = []
-        self.in_order_traversal(root)
-
-        return self.list[k - 1]
+        if not root:
+            return first or []
+        result = self.isValidBST(root.left, False) + [root.val] + self.isValidBST(root.right, False)
+        return all([right > left for right, left in zip(result[1:], result)]) if first else result
 
 ```
\ No newline at end of file

From ecea567eb89e05a7cd5df86d85c1b429f072623a Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 5 Jun 2020 01:38:58 +0300
Subject: [PATCH 24/25] Added LEETCODE "binary-search-tree-iterator" solution.

---
 tree.md | 48 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 36 insertions(+), 12 deletions(-)

diff --git a/tree.md b/tree.md
index 40e49a9..6afeb01 100644
--- a/tree.md
+++ b/tree.md
@@ -1,10 +1,10 @@
 # Binary tree
 
-+ [Validate Binary Search Tree](#validate-binary-search-tree)
++ [Binary Search Tree Iterator](#binary-search-tree-iterator)
 
-## Validate Binary Search Tree
+## Binary Search Tree Iterator
 
-https://leetcode.com/problems/validate-binary-search-tree/
+https://leetcode.com/problems/binary-search-tree-iterator/
 
 ```python
 # Definition for a binary tree node.
@@ -13,19 +13,43 @@ https://leetcode.com/problems/validate-binary-search-tree/
 #         self.val = val
 #         self.left = left
 #         self.right = right
+class BSTIterator(object):
 
+    def push(self, node):
+        """
+        :type node: TreeNode
+        """
+        while node:
+            self.inorderlist.append(node)
+            node = node.left
+
+    def __init__(self, root):
+        """
+        :type root: TreeNode
+        """
+        self.root = root
+        self.inorderlist = []
+        self.push(root)
 
-class Solution(object):
-    def isValidBST(self, _root, first=True):
+    def next(self):
         """
-        :type _root: TreeNode
-        :type first: bool
+        @return the next smallest number
+        :rtype: int
+        """
+        node = self.inorderlist.pop()
+        self.push(node.right)
+        return node.val
+
+    def hasNext(self):
+        """
+        @return whether we have a next smallest number
         :rtype: bool
         """
-        root = _root
-        if not root:
-            return first or []
-        result = self.isValidBST(root.left, False) + [root.val] + self.isValidBST(root.right, False)
-        return all([right > left for right, left in zip(result[1:], result)]) if first else result
+        return len(self.inorderlist) != 0
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
 
 ```
\ No newline at end of file

From 56f3a1014767b38338461fc36f820dd4113fc892 Mon Sep 17 00:00:00 2001
From: Igneaalis <Nostaleal.ru@yandex.ru>
Date: Fri, 5 Jun 2020 02:02:29 +0300
Subject: [PATCH 25/25] Changed method name.

---
 tree.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tree.md b/tree.md
index 6afeb01..c36f895 100644
--- a/tree.md
+++ b/tree.md
@@ -15,7 +15,7 @@ https://leetcode.com/problems/binary-search-tree-iterator/
 #         self.right = right
 class BSTIterator(object):
 
-    def push(self, node):
+    def traverse(self, node):
         """
         :type node: TreeNode
         """
@@ -29,7 +29,7 @@ class BSTIterator(object):
         """
         self.root = root
         self.inorderlist = []
-        self.push(root)
+        self.traverse(root)
 
     def next(self):
         """
@@ -37,7 +37,7 @@ class BSTIterator(object):
         :rtype: int
         """
         node = self.inorderlist.pop()
-        self.push(node.right)
+        self.traverse(node.right)
         return node.val
 
     def hasNext(self):