The time complexities for BFS and DFS are just O(|E|), or in your case, O(m). In a binary tree, m is equal to n-1 so the time complexity is equivalent to O(|V|). m refers to the total number of edges, not the average number of adjacent edges per vertex.
All those articles talk mostly about the serialization part. The deserialization part is slightly tricky to do in one pass. I have implemented an efficient solution for deserialization too. Problem: Serialize and Deserialize a binary tree containing positive numbers. Serialization part: Use 0 to represent null. Serialize to list of integers using preorder traversal. Deserialization … Read more
It’s a pretty well-known problem with the following answer: public boolean isValid(Node root) { return isValidBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE); } private boolean isValidBST(Node node, int l, int h) { if(node == null) return true; return node.value > l && node.value < h && isValidBST(node.left, l, node.value) && isValidBST(node.right, node.value, h); } The recursive call makes sure … Read more
The original paper for Morris traversal is Traversing binary trees simply and cheaply. It claims that time complexity is O(n) in Introduction section: It is also efficient, taking time proportional to the number of nodes in the tree and requiring neither a run-time stack nor ‘flag’ bits in the nodes. The full paper should have … Read more
A balanced binary tree is the binary tree where the depth of the two subtrees of every node never differ by more than 1. A complete binary tree is a binary tree whose all levels except the last level are completely filled and all the leaves in the last level are all to the left … Read more
You can trivially do this by turning the function into CPS (Continuation Passing Style). The idea is that instead of calling depth left, and then computing things based on this result, you call depth left (fun dleft -> …), where the second argument is “what to compute once the result (dleft) is available”. let depth … Read more
It just an assuption you make for the recursive description of the height of a binary tree. You can consider a tree composed by just a node either with 0 height or with 1 height. If you really want to think about it somehow you can think that it’s 0 if you consider the height … Read more
Just build one level at a time, e.g.: class Node(object): def __init__(self, value, left=None, right=None): self.value = value self.left = left self.right = right def traverse(rootnode): thislevel = [rootnode] while thislevel: nextlevel = list() for n in thislevel: print n.value, if n.left: nextlevel.append(n.left) if n.right: nextlevel.append(n.right) print thislevel = nextlevel t = Node(1, Node(2, Node(4, … Read more
Your analysis is wrong, both insertion and deletion is O(n) for a sorted array, because you have to physically move the data to make space for the insertion or compress it to cover up the deleted item. Oh and the worst case for completely unbalanced binary search trees is O(n), not O(logn).
Yes, they can. You can read about this in ‘Introduction to Algorithms’ (by Charles E. Leiserson, Clifford Stein, Thomas H. Cormen, and Ronald Rivest). According to the definition of binary heaps in Wikipedia: All nodes are either [greater than or equal to](max heaps) or [less than or equal to](min heaps) each of its children, according … Read more