code: @Override
      @SuppressWarnings("unchecked")
      @LogarithmicTime(amortized = true)
      public AddressableHeap.Handle<K, V> deleteMin() {
          if (size == 0) {
              throw new NoSuchElementException();
          }
  
          Node<K, V> min;
          if (decreasePoolMinPos >= decreasePoolSize) {
              // decrease pool empty
              min = root;
  
              // cut all children, and combine them
              root = combine(cutChildren(root));
          } else {
              Node<K, V> poolMin = decreasePool[decreasePoolMinPos];
              int c;
              if (comparator == null) {
                  c = ((Comparable<? super K>) root.key).compareTo(poolMin.key);
              } else {
                  c = comparator.compare(root.key, poolMin.key);
              }
  
              if (c <= 0) {
                  // root is smaller
                  min = root;
  
                  // cut children, combine
                  Node<K, V> childrenTree = combine(cutChildren(root));
                  root = null;
  
                  /*
                   * Append to decrease pool without updating minimum as we are
                   * going to consolidate anyway
                   */
                  if (childrenTree != null) {
                      addPool(childrenTree, false);
                  }
                  consolidate();
              } else {
                  // minimum in pool is smaller
                  min = poolMin;
  
                  // cut children, combine
                  Node<K, V> childrenTree = combine(cutChildren(poolMin));
  
                  if (childrenTree != null) {
                      // add to location of previous minimum and consolidate
                      decreasePool[decreasePoolMinPos] = childrenTree;
                      childrenTree.poolIndex = decreasePoolMinPos;
                  } else {
                      decreasePool[decreasePoolMinPos] = decreasePool[decreasePoolSize - 1];
                      decreasePool[decreasePoolMinPos].poolIndex = decreasePoolMinPos;
                      decreasePool[decreasePoolSize - 1] = null;
                      decreasePoolSize--;
                  }
                  poolMin.poolIndex = Node.NO_INDEX;
  
                  consolidate();
              }
          }
  
          size--;
          return min;
      }
docs: {@inheritDoc}