avl-tree | templated AVL tree with STL-style iterators | 3D Printing library

...so what's the story?

The short version is that your find method doesn't return an Integer value. So you can't cast it to an Integer.

It worked fine back in the days, but now it doesn't work any longer.

Well, you must have changed something significant in your code between then and now. (Hint: the Java language or its implementations have not changed in ways that would cause this!)

So lets take a look at your find method.

In theory, no, since the Ω(log n) bound on comparisons still applies to comparison-based sets without deletion.

In practice, I'm not aware of any comparison-based structures that yield an empirical improvement, other than that deletion is often more complicated than insertion, and you don't have to code it. (Bloom filters are an example of a hash-based data structure where not having deletion yields a performance improvement.)

First of all, all the referenced websites agree that the depicted example represents a single right rotation.

You write:

As this for example, LL tree rotation

In this post, it says the LL Rotation is a single left Rotation https://www.freecodecamp.org/news/avl-tree-insertion-rotation-and-balance-factor/

Indeed, although there is no ambiguity for what the terms "left rotation" and "right rotation" mean, there seem to be two contradictory interpretations floating around for what "LL rotation" and "RR rotation" stand for.

However, from the wiki of tree rotation, https://en.wikipedia.org/wiki/Tree_rotation, I think that is a single right Rotation?

Well the Wikipedia article does not use the term "LL rotation". But it does also agree that the depicted example represents a right rotation. There is so far no ambiguity for the terms "left rotation" and "right rotation".

Can anyone tell me the truth for the above picture?

Like all those sites explain: it is a single right rotation.

The ambiguity arises in the use of the terms "LL rotation" and "RR rotation":

The acronyms "LL" and "RR" make more sense in describing the imbalance before any rotation is performed. The Wikipedia article categorises imbalanced trees in 4 categories (4 columns):

In each column you see the original state at the top, and then below it the result of the rotation(s) that should be performed to bring the tree in balance.

So for a tree in the Left Left case, we need a right rotation. And for a tree in the Right Right case we need a left rotation.

The following notes of an ICS course at University of California, Irvine, explain where the letters LL, RR, LR, RL come from:

The rotation is chosen considering the two links along the path below the node where the imbalance is, heading back down toward where you inserted a node. (If you were wondering where the names LL, RR, LR, and RL come from, this is the answer to that mystery.)

• If the two links are both to the left, perform an LL rotation rooted where the imbalance is.
• If the two links are both to the right, perform an RR rotation rooted where the imbalance is.
• If the first link is to the left and the second is to the right, perform an LR rotation rooted where the imbalance is.
• If the first link is to the right and the second is to the left, perform an RL rotation rooted where the imbalance is.

But I feel speaking of LL rotation can trigger confusion, as here we see that the double LL describes the imbalance of the original state, and does not describe the action. It would have been cleaner to speak of an LL state (or imbalance) and then name the resolving action a "right rotation". With that in mind, I think the Wikipedia article takes a good position, as it avoids the term "LL rotation".

This misunderstanding does not arise with LR and RL rotations. You can say that the initial state is LR (the imbalance was caused by giving a left leaf a right child), and you can also say that first a left rotation is needed, and then a right rotation. In both cases the abbreviation LR makes sense. So no ambiguity there.

The terms left rotation and right rotation are clear.

There are different traditions for which of these rotations to call an LL or RR rotation. In my opinion we should avoid talking about "LL rotation" or "RR rotation", as these letters do not describe the act of the rotation, but the initial state. It is better to speak of the "LL case" or "LL imbalance".

With those terms we can say:

• A tree with an LL imbalance needs a right rotation
• A tree with a RR imbalance needs a left rotation

In short: it depends on how the bucket is implemented. With a linked list, it can be done in O(n) under certain conditions. For an implementation with AVL trees as buckets, this can indeed, wost case, result in O(n log n). In order to calculate the time complexity, the implementation of the buckets should be known.

Frequently a bucket is not implemented with an AVL tree, or a tree in general, but with a linked list. If there is a reference to the last entry of the list, appending can be done in O(1). Otherwise we can still reach O(1) by prepending the linked list (in that case the buckets store data in reversed insertion order).

The idea of using a linked list, is that a dictionary that uses a reasonable hashing function should result in few collisions. Frequently a bucket has zero, or one elements, and sometimes two or three, but not much more. In that case, a simple datastructure can be faster, since a simpler data structure usually requires less cycles per iteration.

Some hash tables use open addressing where buckets are not separated data structures, but in case the bucket is already taken, the next free bucket is used. In that case, a search will thus iterate over the used buckets until it has found a matching entry, or it has reached an empty bucket.

The Wikipedia article on Hash tables discusses how the buckets can be implemented.

As mentioned in the comments, the problem is in the "Element found With 2 children" section of remove.

To remove the element, you find the next element in the tree. Your implementation then wants to copy the contents of the found node (temp). You copy the workload value, so that both t and temp have the same workload value (4). You do not copy the numbers list. The t node has a workload of 4 and an empty numbers list, while temp has a workload of 4 and a numbers list consisting of one element, 7. You then delete temp, losing the list.

One fix would be to copy (or move) numbers from temp to t before removing it from the tree. Adding a MoveData method to node that would move the data fields (while not altering the tree specific fields) would make it easier to add new data fields.

Another fix would be to change how you're doing the data update. If you update all pointers (and other tree related fields like height), then you don't have to worry about the data (and any pointers/iterators to the nodes would not be invalidated).

I noticed that you have fixed std::move() issue. But you may need to add the following lines into your program.

As duskwuff said this is a simple unbalanced binary tree, not an AVL one. However, your code is not that bad:

Ok, it's been 14 years since I touched Pascal last time :)

So the problem is indeed with rotate_l function. You are passing a parameter by-reference as indicated by var keyword.

However, since that (now removed) node was once created with the 'new'-> keyword, is it necessary to somehow free the memory it takes up?

It is not mandatory but if you want to avoid eating all your RAM at some point then yes you need to, and you do so with the delete keyword

What I am saying is: even tho the removed node is not included in the tree anymore, e.g. nothing is pointing to it, does it go 'out of scope' and is removed from memory automatically?

No, there is no garbage collector in c++

There are more "modern" ways to do what you are doing but i feel like it is more a learning exercise than something else, in which case matching your delete calls with your new calls manually is a good way to understand what's going on. If you want though you can search for "smart pointers".