The current mailing list, core-libs-dev, is the correct one.
Cheers,
David
On 14/12/2023 9:37 am, Valeh Hajiyev wrote:
Hi Pavel,
Thanks for the reply. If I understand correctly, I need this change to
be discussed in one of the mailing lists there, so that someone would
sponsor me to create a tracking issue in JBS. Do you know which mailing
list is the most relevant for me to propose the change?
Thanks,
Valeh
On Thu, Dec 14, 2023 at 12:26 AM Pavel Rappo <pavel.ra...@oracle.com
<mailto:pavel.ra...@oracle.com>> wrote:
Sorry, there's a necessary process that a PR must follow. You seem
to have signed OCA already. For the rest, see this resource:
https://openjdk.org/guide/ <https://openjdk.org/guide/>. In
particular, this part:
https://openjdk.org/guide/#contributing-to-an-openjdk-project
<https://openjdk.org/guide/#contributing-to-an-openjdk-project>.
-Pavel
> On 13 Dec 2023, at 23:09, Valeh Hajiyev <valeh.haji...@gmail.com
<mailto:valeh.haji...@gmail.com>> wrote:
>
> Hi all,
>
> I have raised the following PR, could someone please help me to
get it merged?
>
> https://github.com/openjdk/jdk/pull/17045
<https://github.com/openjdk/jdk/pull/17045>
>
> More details:
>
> This commit addresses the current limitation in the
`PriorityQueue` implementation, which lacks a constructor to
efficiently create a priority queue with a custom comparator and an
existing collection. In order to create such a queue, we currently
need to initialize a new queue with custom comparator, and after
that populate the queue using `addAll()` method, which in the
background calls `add()` method (which takes `O(logn)` time) for
each element of the collection (`n` times). This is resulting in an
overall time complexity of `O(nlogn)`.
>
> ```
> PriorityQueue<String> pq = new PriorityQueue<>(customComparator);
> pq.addAll(existingCollection);
> ```
>
> The pull request introduces a new constructor to streamline this
process and reduce the time complexity to `O(n)`. If you create the
queue above using the new constructor, the contents of the
collection will be copied (which takes `O(n)` time) and then later
`heapify()` operation (Floyd's algorithm) will be called once
(another `O(n)` time). Overall the operation will be reduced from
`O(nlogn)` to `O(2n)` -> `O(n)` time.
>
> ```
> PriorityQueue<String> pq = new
PriorityQueue<>(existingCollection, customComparator);
> ```
>
> Best regards,
> Valeh Hajiyev
>
