skiplist | Python bindings . | Learning library

The summary of your question is:

• The meaning of group and node objects, and why they have their structure they do.
• What the nodes array is doing on a group.

I'll use an image taken from brilliant.org:

The linked lists appear as horizontal bands, while the arrays appear as vertical stacks.

A group corresponds to one distinct key in the set -- marked in yellow. The corresponding value is not depicted in the image, but is just payload and is not essential for understanding the data structure. A group has a nodes array -- displayed as a stack on top of the key. Each of these nodes belong to a different linked list in which they represent that same key. Those nodes have backreferences again to the group, so a node knows which key it represents, and which other linked lists have a node for this same key.

So the nodes array actually duplicates a key to different lists. One nodes array does not represent different keys in the collection -- just one. It is like an elevator to jump from one train (linked list) to another, with the same key.

The sizes of these arrays are randomly determined, but are intended to be small on average. This is driven by the stackUpProbability. It represents the probability that an array is extended with one more node (upwards in the image). The probability for having at least one node (for a key) is obviously 1, but the probability that the array will have at least one more node in it (and thus have a size of at least 2), is stackUpProbability. The probability that it will have size 3 is (stackUpProbability)²... etc.

This way, the bottom linked list (at layerIndex 1) will have all keys in the collection (one node per key, in sorted order), but any next layer will have fewer keys, and the top layer might only have a hand full. The lists with fewer nodes provide a way to travel fast along the collection in search of a value. This provides a proximity of where a value could be found. Via the "elevator" a search algorithm can step down to lower (slower) linked lists and continue the search there, until it reaches the lowest level where the key will be found (if present), or where it would have been (if not).

Since you've already worked out how to build available you could just zip the two:

The variables data_structure and root are alive and visible only in block scopes pf if statements where they are declared as for example in this if statement

If you look at this line:

SkipList::maxLevels_; refers to the static maxLevels_ member of the SkipList class. So, if you need maxLevels_ to be the maximum level of all the instances of SkipList you have to declare it as static. Otherwise in your overloaded friend function you have to use the private member of the list instance.

Presumably RANDMAX is intended to be RAND_MAX.

Neglecting rounding issues, half the return values of rand are above RAND_MAX / 2, and therefore half the time, the loop exits with i = 1.

If the loop continues, it updates i to 2 and j to 4. Then half the remaining return values (¾ of the total) are above RAND_MAX / 4, so, one-quarter of the time, the loop exits with i = 2.

Further iterations continue in the same manner, each iteration exiting with a portion of return values that is half the previous, until the lg_n_max limit is reached.

Thus, neglecting rounding issues and the final limit, the routine returns 1 half the time, 2 one-quarter of the time, 3 one-eighth the time, and so on.

lg_n is not defined in the routine. It appears to be a record of the greatest value returned by the routine so far.

ziplist is O(n) time complexity for searching and updating and skiplist is O(logN)

The only benefit for ziplist is memory usage. As zip list implement by linear memory address and no pointers to other nodes, it can save a lot of memory space for Redis.

When you only have few members in zset, O(N) and O(logN) will not have significant difference. But memory usage will have huge differences(consider you have 1m keys of zset and each zset only have 10 members).

And when there are a lot of members in zset(like 1m), time complexity is important since it will affect the concurrent performance.

Not sure if this is due to the excerpt you posted, but you should always turn off the autodeclare option and ensure that you always use the correct types for your variables by either checking the DXL manual or by using alternative sources like the "undocumented perms list" . data performed on a ModuleVersion returns type Module. So you already have what you need. An alternative would be the perm bool open(ModName_ modRef). And note that the perm module does not return a Module, but a ModName_. Also, in addition to bool isRead(Module m), bool isEdit(Module m) and bool isShare(Module m)(!!) when you really want to close modules that have been opened previously, you might want to check bool unsaved(Module m)

Is there a elegant implement of the Iterator for the Rc in Rust?

Not really. There's two big things in your way.

One limitation when building an Iterator is that the output type cannot reference the iterator itself. It can either return an owned value (no lifetimes involved) or return references bound to the lifetime of some other object.

I see you've tried to communicate that you want to return Refs bound to the lifetime of the orignal SkipList by using PhantomData<&'a K> and also using 'a in your Iterator::Item. However, since your iterator can only source values from ptr, an owned value with no lifetime-linkage to 'a, the compiler will complain about mismatched lifetimes at one point or another.

In order to do this, your iterator would have to use something bound to 'a, probably some form of Option<'a, _>>.

However, another limitation is when you have nested RefCells, with each level that you iterate, you need to keep around an additional Ref. The reason being that borrows from a Ref don't keep the lifetime of the RefCell, but from the Ref itself.