Solution of Binary Tree Iterator and Right side of Binary Tree

Author: Garvit244

Diff for: 100-200q/173.py

@@ -0,0 +1,47 @@
+'''
+	Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.
+
+	Calling next() will return the next smallest number in the BST.
+
+	Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree. 
+'''
+
+
+# Definition for a  binary tree node
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class BSTIterator(object):
+    def __init__(self, root):
+        """
+        :type root: TreeNode
+        """
+        self.stack = []
+        while root:
+            self.stack.append(root)
+            root = root.left
+        
+
+    def hasNext(self):
+        """
+        :rtype: bool
+        """
+        return self.stack
+
+    def next(self):
+        """
+        :rtype: int
+        """
+        node = self.stack.pop()
+        new_node = node.right
+        while new_node:
+            self.stack.append(new_node)
+            new_node = new_node.left
+        return node.val
+
+# Your BSTIterator will be called like this:
+# i, v = BSTIterator(root), []
+# while i.hasNext(): v.append(i.next())

Diff for: 100-200q/199.py

@@ -0,0 +1,44 @@
+'''
+	Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
+
+	Example:
+
+	Input: [1,2,3,null,5,null,4]
+	Output: [1, 3, 4]
+	Explanation:
+
+	   1            <---
+	 /   \
+	2     3         <---
+	 \     \
+	  5     4       <---
+'''
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def rightSideView(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        if not root:
+        	return []
+
+        stack, node_depth = [(root, 0)], {}
+
+        while stack:
+        	node, depth = stack.pop(0)
+        	if depth not in node_depth:
+        		node_depth[depth] = node.val
+
+        	if node.right:
+        		stack.append((node.right, depth+1))
+        	if node.left:
+        		stack.append((node.left, depth+1))
+        return node_depth.values()

Diff for: README.md

@@ -51,8 +51,10 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 100-200](./100-200q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|199|[Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view)|[Python](./100-200q/199.py)|Medium|
 |191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)| [Python](./100-200q/191.py)|Easy|
 |179|[Largest Number](https://leetcode.com/problems/largest-number/) | [Python](./100-200q/179.py)|Medium|
+|173|[Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator)|[Python](./100-200q/173.py)|Medium|
 |162|[Find Peak Element](https://leetcode.com/problems/find-peak-element/) | [Python](./100-200q/162.py)|Medium|
 |160|[Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) | [Python](./100-200q/160.py)|Easy|
 |155|[Min Stack](https://leetcode.com/problems/min-stack/)| [Python](./100-200q/155.py)|Easy|