题目:
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.
链接: http://leetcode.com/problems/binary-search-tree-iterator/
题解:
二叉搜索树iterator,要求O(1)的next()和hasNext()。可以用in-order traversal。
再仔细看一看,要求O(h)的memory,这样二刷的时候还要再仔细想一想。还有Morris Traversal要学习.
Time Complexity of next() and hasNext() - O(1), Space Complexity - O(n)
/** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class BSTIterator { private Queue<Integer> queue; //left, mid ,right public BSTIterator(TreeNode root) { this.queue = new LinkedList<>(); inOrderTraversal(root); } private void inOrderTraversal(TreeNode root) { if(root == null) return; Stack<TreeNode> stack = new Stack<>(); while(root != null || !stack.isEmpty()) { if(root != null) { stack.push(root); root = root.left; } else { root = stack.pop(); queue.offer(root.val); root = root.right; } } } /** @return whether we have a next smallest number */ public boolean hasNext() { return !queue.isEmpty(); } /** @return the next smallest number */ public int next() { if(hasNext()) return queue.poll(); return Integer.MAX_VALUE; } } /** * Your BSTIterator will be called like this: * BSTIterator i = new BSTIterator(root); * while (i.hasNext()) v[f()] = i.next(); */
二刷:
一刷写得不智慧。注意这里题目要求是amortized complexity - O(1)。是total expense of one operation。所以我们可以用把in-order traversal分解为左右两部分,然后分别放入stack中,就可以满足题目要求了。
为什么是amortized O(1)呢? 因为在我们遍历整个树的过程中,对每个节点都只push 1次,所以对于遍历n个节点的树,我们总的expense是 O(n),那amortized complexity就等于 O(1)了。
空间复杂度的减少,最好还是用Morris-traversal,下一次一定要好好写一遍。
Java:
Time Complexity: next() - amortized O(1), hasNext() - O(1), Space Complexity - O(h)
/** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class BSTIterator { Stack<TreeNode> stack; public BSTIterator(TreeNode root) { stack = new Stack<>(); inorder(root); } /** @return whether we have a next smallest number */ public boolean hasNext() { return !stack.isEmpty(); } /** @return the next smallest number */ public int next() { TreeNode root = stack.pop(); inorder(root.right); return root.val; } private void inorder(TreeNode root) { while (root != null) { stack.push(root); root = root.left; } } } /** * Your BSTIterator will be called like this: * BSTIterator i = new BSTIterator(root); * while (i.hasNext()) v[f()] = i.next(); */
Reference:
https://leetcode.com/discuss/20001/my-solutions-in-3-languages-with-stack
https://leetcode.com/discuss/20101/ideal-solution-using-stack-java
https://leetcode.com/discuss/30207/my-simple-solution-here
https://leetcode.com/discuss/23721/morris-traverse-solution
http://stackoverflow.com/questions/15079327/amortized-complexity-in-laymans-terms
https://en.wikipedia.org/wiki/Amortized_analysis