int initialCapacity, @Nullable Comparator<? super E> comparator) {
    q = new PriorityQueue<E>(initialCapacity, comparator);
  }

  /**
   * Creates a {@code MonitorBasedPriorityBlockingQueue} containing the elements in the specified
   * collection. If the specified collection is a {@link SortedSet} or a {@link PriorityQueue}, this
   * priority queue will be ordered according to the same ordering. Otherwise, this priority queue

  public static <E extends Comparable> PriorityQueue<E> newPriorityQueue() {
    return new PriorityQueue<>();
  }

  /**
   * Creates a {@code PriorityQueue} containing the given elements.
   *
   * <p><b>Note:</b> If the specified iterable is a {@code SortedSet} or a {@code PriorityQueue},
   * this priority queue will be ordered according to the same ordering.
   *

    }

    /**
     * Creates and returns a new instance of {@link PriorityQueue}.
     *
     * @param <E> the element type of {@link PriorityQueue}
     * @return a new instance of {@link PriorityQueue}
     * @see PriorityQueue#PriorityQueue()
     */
    public static <E> PriorityQueue<E> newPriorityQueue() {
        return new PriorityQueue<>();
    }

    /**

  public static <E extends Comparable> PriorityQueue<E> newPriorityQueue() {
    return new PriorityQueue<>();
  }

  /**
   * Creates a {@code PriorityQueue} containing the given elements.
   *
   * <p><b>Note:</b> If the specified iterable is a {@code SortedSet} or a {@code PriorityQueue},
   * this priority queue will be ordered according to the same ordering.
   *

    assertTrue(ArbitraryInstances.get(PriorityQueue.class).isEmpty());
    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeMap.class).isEmpty());
    assertFreshInstanceReturned(
        LinkedList.class,
        Deque.class,
        Queue.class,
        PriorityQueue.class,
        BitSet.class,

    assertTrue(ArbitraryInstances.get(PriorityQueue.class).isEmpty());
    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeMap.class).isEmpty());
    assertFreshInstanceReturned(
        LinkedList.class,
        Deque.class,
        Queue.class,
        PriorityQueue.class,
        BitSet.class,

    }
  }

  public void testCorrectOrdering_randomAccess() {
    long seed = new Random().nextLong();
    Random random = new Random(seed);
    PriorityQueue<Integer> control = new PriorityQueue<>();
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create();
    for (int i = 0; i < 73; i++) { // 73 is a childless uncle case.
      Integer element = random.nextInt();

 * #offer} and a call to {@link #topK}, with O(k) memory. In comparison, quickselect has the same
 * asymptotics but requires O(n) memory, and a {@code PriorityQueue} implementation takes O(n log
 * k). In benchmarks, this implementation performs at least as well as either implementation, and
 * degrades more gracefully for worst-case input.
 *

import java.util.Comparator;
import java.util.Deque;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * This class contains static utility methods that operate on or return objects of type {@link