SkipList | A Java implementation of skip list 跳表的Java语言实现 | Learning library

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.

wiht list comprehension:

If you want your code to be able to update existing elements when inserting a new value, then you have to combine the searching you do in containsSkipList() with the creation of a new skipLink. So:

„…how is SkipList concurrent when it doesn't have any synchronization in it?…“

TL;DR — ConcurrentSkipListSet is concurrent because the elements it holds cannot be written to at the same time by concurrently executing threads. It achieves its concurrency without using synchronized and locks.

The long version

Concurrency in the context of the concurrent collections, does not necessarily mean those classes all implement thread safety using monitors (aka, the synchronized keyword).

First you should understand that thread safety is essentially about ensuring that two or more competing threads do not modify the shared state of an application. Then you realize that there are ways (some more performant) other than synchronized to achieve thread safety.

Making sure your state cannot be modified (that it's immutable) in the first place is one simple but very effective way to get thread safety.

Also, a class can be thread safe by delegating its thread safety responsibilities to a different, thread-safe class.

ConcurrentSkipListSet is considered to be concurrent because, as its Javadoc says, its: „Insertion, removal, update, and access operations safely execute concurrently by multiple threads“.

It achieves its concurrency because it delegates its thread safety responsibilities to a thread-safe class; namely: ConcurrentSkipListMap.

ConcurrentSkipListSet is thread-safe because ConcurrentSkipListMap is. And ConcurrentSkipListMap is thread-safe because, by using AbstractMap.SimpleImmutableEntry internally, it guarantees that none of its state (its keys and values) can be modified by currently executing threads, because its state is immutable.

You can see ConcurrentSkipListSet delegating to ConcurrentSkipListMap at several places in the source code I linked to above. If you're interested in learning more about delegating thread safety, I recommend you read Chapter 4, Composing Objects, Java Concurrency In Practice.

„…What problems can it help me with“

Using it gets you free thread-safety. The kind that is way more performant — and with way less risk of shooting yourself in the foot — than using synchronized.

„…why should I ever use it other than this difference between Iterators?“

If the state of your application needs to be stored in some collection and that collection will be accessible in any way to concurrently executing threads, then using ConcurrentSkipListSet is a thread-safe option that you have.

The issue is that T.RawValue can be something else than Int with your current type constraints. You need to specify that T.RawValue == Int in order to pass your rawValue: Int input parameter to init(rawValue:).

Your add function is accepting 2 params

I guess you have problem with installation of pandas module. Try to run command "pip install pandas" first may be your pandas package is not install. then you can run pyinstaller.

However you can do additional things like setup settings follow below example:

Please fill "install_requires" whatever packages you want.

I'm going to assume you're referring to how to find the k-th smallest (or largest) element in a skip list. This is a rather standard assumption I think, otherwise you have to clarify what you mean.

I'll refer to the GIF on wikipedia in this answer: https://en.wikipedia.org/wiki/Skip_list

Let's say you want to find the k = 5 smallest element.

You start from the highest level (4 in the figure). How many elements would you skip from 30 to NIL? 6 (we also count the 30). That's too much.

Go down a level. How many skipped from 30 to 50? 2: 30 and 40.

So we reduced the problem to finding the k = 5 - 2 = 3 smallest element starting at 50 on level 3.

How many skipped from 50 to NIL? 4, that's one too many.

Go down a level. How many skipped from 50 to 70? 2. Now find the 3 - 2 = 1 smallest element starting from 70 on level 2.

How many skipped from 70 to NIL? 2, one too many.

From 70 to 90 on level 1? 1 (itself). So the answer is 70.

So you need to store how many nodes are skipped for each node at each level and use that extra information in order to get an efficient solution. That seems to be what fDistance[i] does in your code.