1
/ \
2 7
/ \ / \
3 4 5 6
1
/ / \ \
3 4 5 6
I'm looking for an algorithm to reduce a tree by cutting out nodes at a specific level and save all the leaves. This example is very simple, so the function my have to be recursive - imagine cutting a tree at level 3 and eliminating nodes at levels 4,5,6,7 - but preserving the leaves by inserting them all at level 4.
Related
In Data Structures and Algorithm Analysis in C++ (4th Edition) by Mark Allen Weiss, on page 162 at figure 4.50, the book describes how splaying the left most child of tree with only left children would ultimately look like.
Where I am confused is how the book gets from step 2 to step 3. Here are the steps highlighted on page 162 at figure 4.50:
Whereas my thirds step looks like this:
7
/
6
/
1
\
3
/ \
2 4
\
5
And my fourth and final step like this:
1
\
4
/ \
3 6
/ / \
2 5 7
I am confused as to how the book is balancing the tree. For me, when 1 surpassed 4 the bottom of the tree looked like this:
...
/
1
\
2
\
3
\
4
My logic was that the root where the balance would occur would be 2. Then you would do a left rotation and the bottom of the tree would look like this:
...
/
1
\
3
/ \
2 4
Am I doing something wrong or am I just doing it in a different but equally valid to the book way? I am also confused because the book's final tree is imbalanced from the root of 6 whereas my root of 4 doesn't have an imbalance.
This is mostly the "Zig-zig" case till upwards, so each time you do a right rotation on the node's grandparent followed by a right rotation on the parent.
Take example:
5
/
4
/
3
/
2
/
1
If you want to splay 1, you rotate right around 3 then 2, resulting in:
5
/
4
/
1
\
2
\
3
Since it is Zig-Zig case again, we rotate around 5 then 4, resulting:
1
\
4
/ \
2 5
\
3
So you keep doing this until you have 1 as root. There are 3 cases, Zig-Zig, Zig and Zig-Zag. Here is a tool that visualizes the whole concept it will be helpful I believe.
Here are the combinations of different BSTs with same element, the arrangement looks different depending on the sequence of addition of nodes to the tree structure:
1 1 1 1 1
\ \ \ \ \
2 2 3 4 4
\ \ / \ / /
3 4 2 4 3 2
\ / / \
4 3 2 3
2 2 3 3 4 4 4
/ \ / \ / \ / \ / / /
1 3 1 4 2 4 1 4 3 2 3
\ / / \ / / \ /
4 3 1 2 2 1 3 1
/ \
1 2
4 4
/ /
1 1
\ \
2 3
\ /
3 2
Their in-order traversal will be same, so how do we distinguish them? Especially when there are more than one sequence of adding the nodes and they all generate the same structure, example 2,1,4,5,2,4,1,3,2,4,3,1.
You mentioned that all your examples have the same in-order traversal (1234), meaning inorder is not enough information to derive the tree structure. However, both post-order and pre-order sequences are sufficient for deriving the tree structure of a binary search tree.
For example, given the pre-order 2-1-3-4, the only binary search tree that satisfies this pre-order is your row 2 col 1 example. Compare that to pre-order 2-1-4-3 which would be your row 2 col 2 example.
For all of your examples, here are their pre-order notations
[1234] [1243] [1324] [1432] [1423]
[2134] [2143] [3214] [3124] [4321] [4213] [4312]
[4123] [4132]
As you can see, they are all distinct. You can repeat the same process for their post-order traversal, and you should get all distinct results.
I have a graph shaped as a triangle.
8
/ \
1 4
/ \ / \
4 2 0
/ \ / \ / \
9 1 9 4
In the above graph the longest path is {8, 4, 2, 9}
My current algorithm calculates the max number of the adjacent nodes and add it to the list, then calculates the sum of that list. This works in the above graph but won't work in situations such as this scenario:
8
/ \
0 1
/ \ / \
4 0 4
/ \ / \ / \
9 99 3 4
My algorithm will mistakenly go through {8,1,4,4} where the correct longest path is {8,0,4,99}
The only solution I can think of is Backtracking. Where I have to go through all the paths and calculate the max path, which will be insanely slow in a huge graph. This about a 100k nodes graph.
My question is can I do better than this?
Start at the top.
For each node, pick the maximum of its parents (the nodes above connected to it) and add its own value.
Then, in the last row, pick the maximum.
This will just give you the value of the longest path, but you could easily get the actual path by simply starting at the value picked at the bottom and moving upwards, always picking the greater parent.
The running time would be linear in the number of nodes.
Example:
Original:
First example: Second example:
8 8
/ \ / \
1 4 0 1
/ \ / \ / \ / \
4 2 0 4 0 4
/ \ / \ / \ / \ / \ / \
9 1 9 4 9 99 3 4
Output:
First example: Second example:
8 8
/ \ / \
9 12 8 9
/ \ / \ / \ / \
13 14 12 12 9 13
/ \ / \ / \ / \ / \ / \
22 15 23 16 21 111 16 17
Then you'd pick 23 for the first and 111 for the second.
To get the path, we'd have 23-14-12-8, which corresponds to 9-2-4-8, for the first, and 111-12-8-8, which corresponds to 99-4-0-8, for the second.
I'm of course assuming we have a tree, as stated. For general graphs, this problem is quite a lot more difficult - NP-hard, to be exact.
You do not need backtracking here - you can use breadth-first search to propagate the max for the path that you have found so far to the corresponding node, level by level.
Start at the root, and set its max to its own value.
Go through nodes level-by-level
For each node check the max stored in its parent. There may be one or two of these parents. Pick the max of two max-es, add the value of the node itself, and store it in the current node
When the path through the graph is complete, the result would look like this:
Max graph:
8
/ \
8 9
/ \ / \
12 9 13
/ \ / \ / \
21 111 16 17
To recover a path, find the max value in the bottom layer. This is the final node of your path. You can reconstruct the path from the max graph and the original by starting at the max (111), subtracting the value (99), looking for the result (111-99=12) in the max graph, and continuing to that node until you reach the top:
111 - 99 = 12 -- Take 99
12 - 4 = 8 -- Take 4
8 - 0 = 8 -- Take 0
8 is the root -- Take 8
This gives you the max path in reverse. Note that this may not be the unique path (think of a graph filled with equal values to see how there may be multiple max paths). In this case, however, any path that you would recover will satisfy the max path requirement.
If we have V values for a search tree where the values are V= {1,2,3,4,5,6,7} inserted from right to left
And we are to order it to get the largest and shortest height possible -- how would we do it? Would it require the best and worst (lg2 (n+1)) case??
And would the orderings be unique?
Thanks -- I kinda understand but am not sure on what steps i should take.
The largest height is easy; put them in order:
1
\
2
\
...
With the smallest height, sort them, take the middle as the root, and put the two sides one either branch. Rinse and repeat.
3
/ \
2 5
/ / \
1 4 6
\
7
So... n for the first one, and log_2(n) for the second (rounded up).
The tallest such trees are created by inserting the values from a sorted sequence
1 2 3 4 5 6 7
or
7 6 5 4 3 2 1
The shortest tree is made by ordering the values via a recursive algorithm that finds the median then processes the left and right subtrees recursively:
4 2 1 3 6 5 7
This produces a tree of logarithmic height:
4
/ \
2 6
/ \ / \
1 3 5 7
Here the median is 4, so that goes first.
4
Now you have a partition for the left (1, 2, 3) and right (5, 6, 7). To order the left, start with its median, 2. Now you have 1 and 3 for its subtrees. These are 1 element sets so that's your base case.
4 2 1 3
Now process your right subtree (5, 6, 7), starting with 6.
4 2 1 3 6 5 7
I wanted to draw a balanced binary search tree for numbers from 1 to 20.
_______10_______
/ \
___5___ 15
/ \ / \
3 8 13 18
/ \ / \ / \ / \
2 4 7 9 12 14 17 19
/ / / /
1 6 11 16
Is the above tree correct and balanced?
In answer to your original question as to whether or not you need to first calculate the height, no, you don't need to. You just have to understand that a balanced tree is one where the height difference between the tallest and shortest node is zero or one, and the simplest way to achieve this is to ensure that you always pick the midpoint of the possible list, when populating the top node in a sub-tree.
Your sample tree is balanced since all leaf nodes are either at the bottom or next-to-bottom level, hence the difference in heights between any two leaf nodes is at most one.
To create a balanced tree from the numbers 1 through 20 inclusive, you can just make the root entry 10 or 11 (the midpoint being 10.5 for those numbers), so that there's an equal quantity of numbers in either sub-tree.
Then just do that recursively for each sub-tree. On the lower side of 10, 5 is the midpoint:
10
/ \
5 11-thru-19 sub-tree
/ \
1-thru-4 6-thru-9
sub-tree sub-tree
Just expand on that and you'll end up with something like:
_______10_______
/ \
___5___ 15
/ \ / \
2 7 13 17
/ \ / \ / / \
1 3 6 8 11 16 18 <- depth of highest leaf node
\ \ \ \
4 9 12 19 <- depth of lowest leaf node
^
|
Difference is 1
The midpoint can be found at the number where the difference between quantities above and below that numbers is one or zero. For the whole list of numbers 1 through 20 inclusive, there are nine less than 10 and ten greater than 10 (or, if you chose 11 as the midpoint, the quantities are ten and nine).
The difference between your sample and mine is probably to do with the fact that I preferred to pick the midpoint by rounding down where there was a choice (meaning my right sub-trees tend to be "heavier"). Because your left sub-trees are heavier, you appear to have rounded up.
After choosing 10 as the initial midpoint, there's no leeway on the left sub-tree, you have to choose 5 since it has four above and below it. Any other midpoint would result in a difference of at least two between the two halves (for example, choosing 4 as the midpoint would have the two halves of size three and five). This can still give you a balanced sub-tree depending on the data but it's "safer" to choose the midpoint.