How to use

percolateDownMinHeap

method

in

org.apache.commons.collections.buffer.PriorityBuffer

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

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; 
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

/**
 * Gets and removes the next element (pop).
 *
 * @return the next element
 * @throws BufferUnderflowException if the buffer is empty
 */
public Object remove() {
  final Object result = get();
  elements[1] = elements[size--];
  // set the unused element to 'null' so that the garbage collector
  // can free the object if not used anywhere else.(remove reference)
  elements[size + 1] = null;
  if (size != 0) {
    // percolate top element to it's place in tree
    if (ascendingOrder) {
      percolateDownMinHeap(1);
    } else {
      percolateDownMaxHeap(1);
    }
  }
  return result;
}

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; 
}

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; 
}

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; 
}