How to use

compare

method

in

org.apache.commons.collections.buffer.PriorityBuffer

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element down heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index for the element
 */
protected void percolateDownMinHeap(final int index) {
  final Object element = elements[index];
  int hole = index;
  while ((hole * 2) <= size) {
    int child = hole * 2;
    // if we have a right child and that child can not be percolated
    // up then move onto other child
    if (child != size && compare(elements[child + 1], elements[child]) < 0) {
      child++;
    }
    // if we found resting place of bubble then terminate search
    if (compare(elements[child], element) >= 0) {
      break;
    }
    elements[hole] = elements[child];
    hole = child;
  }
  elements[hole] = element;
}

/**
 * Percolates element down heap from the position given by the index.
 * <p>
 * Assumes it is a maximum heap.
 *
 * @param index the index of the element
 */
protected void percolateDownMaxHeap(final int index) {
  final Object element = elements[index];
  int hole = index;
  while ((hole * 2) <= size) {
    int child = hole * 2;
    // if we have a right child and that child can not be percolated
    // up then move onto other child
    if (child != size && compare(elements[child + 1], elements[child]) > 0) {
      child++;
    }
    // if we found resting place of bubble then terminate search
    if (compare(elements[child], element) <= 0) {
      break;
    }
    elements[hole] = elements[child];
    hole = child;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element down heap from the position given by the index.
 * <p>
 * Assumes it is a maximum heap.
 *
 * @param index the index of the element
 */
protected void percolateDownMaxHeap(final int index) {
  final Object element = elements[index];
  int hole = index;
  while ((hole * 2) <= size) {
    int child = hole * 2;
    // if we have a right child and that child can not be percolated
    // up then move onto other child
    if (child != size && compare(elements[child + 1], elements[child]) > 0) {
      child++;
    }
    // if we found resting place of bubble then terminate search
    if (compare(elements[child], element) <= 0) {
      break;
    }
    elements[hole] = elements[child];
    hole = child;
  }
  elements[hole] = element;
}

/**
 * Percolates element down heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index for the element
 */
protected void percolateDownMinHeap(final int index) {
  final Object element = elements[index];
  int hole = index;
  while ((hole * 2) <= size) {
    int child = hole * 2;
    // if we have a right child and that child can not be percolated
    // up then move onto other child
    if (child != size && compare(elements[child + 1], elements[child]) < 0) {
      child++;
    }
    // if we found resting place of bubble then terminate search
    if (compare(elements[child], element) >= 0) {
      break;
    }
    elements[hole] = elements[child];
    hole = child;
  }
  elements[hole] = element;
}

public void remove() {
  if (lastReturnedIndex == -1) {
    throw new IllegalStateException();
  }
  elements[ lastReturnedIndex ] = elements[ size ];
  elements[ size ] = null;
  size--;  
  if( size != 0 && lastReturnedIndex <= size) {
    int compareToParent = 0;
    if (lastReturnedIndex > 1) {
      compareToParent = compare(elements[lastReturnedIndex], 
        elements[lastReturnedIndex / 2]);  
    }
    if (ascendingOrder) {
      if (lastReturnedIndex > 1 && compareToParent < 0) {
        percolateUpMinHeap(lastReturnedIndex); 
      } else {
        percolateDownMinHeap(lastReturnedIndex);
      }
    } else {  // max heap
      if (lastReturnedIndex > 1 && compareToParent > 0) {
        percolateUpMaxHeap(lastReturnedIndex); 
      } else {
        percolateDownMaxHeap(lastReturnedIndex);
      }
    }          
  }
  index--;
  lastReturnedIndex = -1; 
}

public void remove() {
  if (lastReturnedIndex == -1) {
    throw new IllegalStateException();
  }
  elements[ lastReturnedIndex ] = elements[ size ];
  elements[ size ] = null;
  size--;  
  if( size != 0 && lastReturnedIndex <= size) {
    int compareToParent = 0;
    if (lastReturnedIndex > 1) {
      compareToParent = compare(elements[lastReturnedIndex], 
        elements[lastReturnedIndex / 2]);  
    }
    if (ascendingOrder) {
      if (lastReturnedIndex > 1 && compareToParent < 0) {
        percolateUpMinHeap(lastReturnedIndex); 
      } else {
        percolateDownMinHeap(lastReturnedIndex);
      }
    } else {  // max heap
      if (lastReturnedIndex > 1 && compareToParent > 0) {
        percolateUpMaxHeap(lastReturnedIndex); 
      } else {
        percolateDownMaxHeap(lastReturnedIndex);
      }
    }          
  }
  index--;
  lastReturnedIndex = -1; 
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from from the position given by the index.
 * <p>
 * Assume it is a maximum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMaxHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) > 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}

/**
 * Percolates element up heap from the position given by the index.
 * <p>
 * Assumes it is a minimum heap.
 *
 * @param index the index of the element to be percolated up
 */
protected void percolateUpMinHeap(final int index) {
  int hole = index;
  Object element = elements[hole];
  while (hole > 1 && compare(element, elements[hole / 2]) < 0) {
    // save element that is being pushed down
    // as the element "bubble" is percolated up
    final int next = hole / 2;
    elements[hole] = elements[next];
    hole = next;
  }
  elements[hole] = element;
}