Here’s just an outline of the idea: In a BST, the left subtree of node T contains only elements smaller than the value stored in T. If k is smaller than the number of elements in the left subtree, the kth smallest element must belong to the left subtree. Otherwise, if k is larger, then … Read more
Stumbled across this old question while searching for something else. I notice that you never did get a complete answer. The way to solve this problem is to start by writing a specification for the function you are trying to write. Specification: A well-formed binary tree is said to be “height-balanced” if (1) it is … Read more
Here is my simple recursive implementation of binary search tree. #!/usr/bin/python class Node: def __init__(self, val): self.l = None self.r = None self.v = val class Tree: def __init__(self): self.root = None def getRoot(self): return self.root def add(self, val): if self.root is None: self.root = Node(val) else: self._add(val, self.root) def _add(self, val, node): if val … Read more
When to use Pre-Order, In-Order, and Post-Order Traversal Strategy Before you can understand under what circumstances to use pre-order, in-order and post-order for a binary tree, you have to understand exactly how each traversal strategy works. Use the following tree as an example. The root of the tree is 7, the left most node is … Read more
If I am reading the algorithm right, this should be an example of how it works: X / \ Y Z / \ / \ A B C D First, X is the root, so it is initialized as current. X has a left child, so X is made the rightmost right child of X‘s … Read more
Starting from root node and moving downwards if you find any node that has either p or q as its direct child then it is the LCA. (edit – this should be if p or q is the node’s value, return it. Otherwise it will fail when one of p or q is a direct … Read more
Many algorithms will specify that duplicates are excluded. For example, the example algorithms in the MIT Algorithms book usually present examples without duplicates. It is fairly trivial to implement duplicates (either as a list at the node, or in one particular direction.) Most (that I’ve seen) specify left children as <= and right children as … Read more
Print a [large] tree by lines. output example: z ├── c │ ├── a │ └── b ├── d ├── e │ └── asdf └── f code: public class TreeNode { final String name; final List<TreeNode> children; public TreeNode(String name, List<TreeNode> children) { this.name = name; this.children = children; } public String toString() { StringBuilder buffer = new StringBuilder(50); print(buffer, “”, “”); return buffer.toString(); } … Read more
Summary Type BST (*) Heap Insert average log(n) 1 Insert worst log(n) log(n) or n (***) Find any worst log(n) n Find max worst 1 (**) 1 Create worst n log(n) n Delete worst log(n) log(n) All average times on this table are the same as their worst times except for Insert. *: everywhere in … Read more
Skip lists are more amenable to concurrent access/modification. Herb Sutter wrote an article about data structure in concurrent environments. It has more indepth information. The most frequently used implementation of a binary search tree is a red-black tree. The concurrent problems come in when the tree is modified it often needs to rebalance. The rebalance … Read more