priorityq-heap.c File Reference

#include <stddef.h>
#include <assert.h>
#include "priorityq-heap.h"
#include "memalloc.h"
#include "geom.h"

Include dependency graph for priorityq-heap.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	INIT_SIZE   32
#define	TRUE   1
#define	FALSE   0
#define	LEQ(x, y)   VertLeq((GLUvertex *)x, (GLUvertex *)y)

Functions
PriorityQ *	pqNewPriorityQ (int(*leq)(PQkey key1, PQkey key2))
void	pqDeletePriorityQ (PriorityQ *pq)
static void	FloatDown (PriorityQ *pq, long curr)
static void	FloatUp (PriorityQ *pq, long curr)
void	pqInit (PriorityQ *pq)
PQhandle	pqInsert (PriorityQ *pq, PQkey keyNew)
PQkey	pqExtractMin (PriorityQ *pq)
void	pqDelete (PriorityQ *pq, PQhandle hCurr)

Macro Definition Documentation

FALSE

#define FALSE   0

INIT_SIZE

#define INIT_SIZE   32

LEQ

#define LEQ	(		x,
			y
	)		VertLeq((GLUvertex *)x, (GLUvertex *)y)

TRUE

#define TRUE   1

Function Documentation

FloatDown()

static void FloatDown ( PriorityQ *  pq, long  curr  )

static

{
  PQnode *n = pq->nodes;
  PQhandleElem *h = pq->handles;
  PQhandle hCurr, hChild;
  long child;
 
  hCurr = n[curr].handle;
  for( ;; ) {
    child = curr << 1;
    if( child < pq->size && LEQ( h[n[child+1].handle].key,
         h[n[child].handle].key )) {
      ++child;
    }
 
    assert(child <= pq->max);
 
    hChild = n[child].handle;
    if( child > pq->size || LEQ( h[hCurr].key, h[hChild].key )) {
      n[curr].handle = hCurr;
      h[hCurr].node = curr;
      break;
    }
    n[curr].handle = hChild;
    h[hChild].node = curr;
    curr = child;
  }
}

References PQnode::handle, PriorityQ::handles, LEQ, PQhandleElem::node, PriorityQ::nodes, and PriorityQ::size.

Referenced by pqDelete(), pqExtractMin(), and pqInit().

Here is the caller graph for this function:

FloatUp()

static void FloatUp ( PriorityQ *  pq, long  curr  )

static

{
  PQnode *n = pq->nodes;
  PQhandleElem *h = pq->handles;
  PQhandle hCurr, hParent;
  long parent;
 
  hCurr = n[curr].handle;
  for( ;; ) {
    parent = curr >> 1;
    hParent = n[parent].handle;
    if( parent == 0 || LEQ( h[hParent].key, h[hCurr].key )) {
      n[curr].handle = hCurr;
      h[hCurr].node = curr;
      break;
    }
    n[curr].handle = hParent;
    h[hParent].node = curr;
    curr = parent;
  }
}

References PQnode::handle, PriorityQ::handles, LEQ, PQhandleElem::node, and PriorityQ::nodes.

Referenced by pqDelete(), and pqInsert().

Here is the caller graph for this function:

pqDelete()

void pqDelete	(	PriorityQ *	pq,
		PQhandle	hCurr
	)

{
  PQnode *n = pq->nodes;
  PQhandleElem *h = pq->handles;
  long curr;
 
  assert( hCurr >= 1 && hCurr <= pq->max && h[hCurr].key != NULL );
 
  curr = h[hCurr].node;
  n[curr].handle = n[pq->size].handle;
  h[n[curr].handle].node = curr;
 
  if( curr <= -- pq->size ) {
    if( curr <= 1 || LEQ( h[n[curr>>1].handle].key, h[n[curr].handle].key )) {
      FloatDown( pq, curr );
    } else {
      FloatUp( pq, curr );
    }
  }
  h[hCurr].key = NULL;
  h[hCurr].node = pq->freeList;
  pq->freeList = hCurr;
}

References FloatDown(), FloatUp(), PriorityQ::freeList, PQnode::handle, PriorityQ::handles, PQhandleElem::key, LEQ, PQhandleElem::node, PriorityQ::nodes, and PriorityQ::size.

Here is the call graph for this function:

pqDeletePriorityQ()

void pqDeletePriorityQ

(

PriorityQ *

pq

)

{
  memFree( pq->handles );
  memFree( pq->nodes );
  memFree( pq );
}

References PriorityQ::handles, memFree, and PriorityQ::nodes.

pqExtractMin()

PQkey pqExtractMin

(

PriorityQ *

pq

)

{
  PQnode *n = pq->nodes;
  PQhandleElem *h = pq->handles;
  PQhandle hMin = n[1].handle;
  PQkey min = h[hMin].key;
 
  if( pq->size > 0 ) {
    n[1].handle = n[pq->size].handle;
    h[n[1].handle].node = 1;
 
    h[hMin].key = NULL;
    h[hMin].node = pq->freeList;
    pq->freeList = hMin;
 
    if( -- pq->size > 0 ) {
      FloatDown( pq, 1 );
    }
  }
  return min;
}

References FloatDown(), PriorityQ::freeList, PQnode::handle, PriorityQ::handles, PQhandleElem::key, PQhandleElem::node, PriorityQ::nodes, and PriorityQ::size.

Here is the call graph for this function:

pqInit()

void pqInit

(

PriorityQ *

pq

)

{
  long i;
 
  /* This method of building a heap is O(n), rather than O(n lg n). */
 
  for( i = pq->size; i >= 1; --i ) {
    FloatDown( pq, i );
  }
  pq->initialized = TRUE;
}

References FloatDown(), PriorityQ::initialized, PriorityQ::size, and TRUE.

Here is the call graph for this function:

pqInsert()

PQhandle pqInsert	(	PriorityQ *	pq,
		PQkey	keyNew
	)

{
  long curr;
  PQhandle free_handle;
 
  curr = ++ pq->size;
  if( (curr*2) > pq->max ) {
    PQnode *saveNodes= pq->nodes;
    PQhandleElem *saveHandles= pq->handles;
 
    /* If the heap overflows, double its size. */
    pq->max <<= 1;
    pq->nodes = (PQnode *)memRealloc( pq->nodes, 
             (size_t) 
             ((pq->max + 1) * sizeof( pq->nodes[0] )));
    if (pq->nodes == NULL) {
       pq->nodes = saveNodes; /* restore ptr to free upon return */
       return LONG_MAX;
    }
    pq->handles = (PQhandleElem *)memRealloc( pq->handles,
                           (size_t)
                            ((pq->max + 1) * 
                 sizeof( pq->handles[0] )));
    if (pq->handles == NULL) {
       pq->handles = saveHandles; /* restore ptr to free upon return */
       return LONG_MAX;
    }
  }
 
  if( pq->freeList == 0 ) {
    free_handle = curr;
  } else {
    free_handle = pq->freeList;
    pq->freeList = pq->handles[free_handle].node;
  }
 
  pq->nodes[curr].handle = free_handle;
  pq->handles[free_handle].node = curr;
  pq->handles[free_handle].key = keyNew;
 
  if( pq->initialized ) {
    FloatUp( pq, curr );
  }
  assert(free_handle != LONG_MAX);
  return free_handle;
}

References FloatUp(), PriorityQ::freeList, PQnode::handle, PriorityQ::handles, PriorityQ::initialized, PQhandleElem::key, PriorityQ::max, memRealloc, PQhandleElem::node, PriorityQ::nodes, and PriorityQ::size.

Here is the call graph for this function:

pqNewPriorityQ()

PriorityQ * pqNewPriorityQ

(

int(*)(PQkey key1, PQkey key2)

leq

)

{
  PriorityQ *pq = (PriorityQ *)memAlloc( sizeof( PriorityQ ));
  if (pq == NULL) return NULL;
 
  pq->size = 0;
  pq->max = INIT_SIZE;
  pq->nodes = (PQnode *)memAlloc( (INIT_SIZE + 1) * sizeof(pq->nodes[0]) );
  if (pq->nodes == NULL) {
     memFree(pq);
     return NULL;
  }
 
  pq->handles = (PQhandleElem *)memAlloc( (INIT_SIZE + 1) * sizeof(pq->handles[0]) );
  if (pq->handles == NULL) {
     memFree(pq->nodes);
     memFree(pq);
     return NULL;
  }
 
  pq->initialized = FALSE;
  pq->freeList = 0;
  pq->leq = leq;
 
  pq->nodes[1].handle = 1;  /* so that Minimum() returns NULL */
  pq->handles[1].key = NULL;
  return pq;
}

References FALSE, PriorityQ::freeList, PQnode::handle, PriorityQ::handles, INIT_SIZE, PriorityQ::initialized, PQhandleElem::key, PriorityQ::leq, PriorityQ::max, memAlloc, memFree, PriorityQ::nodes, and PriorityQ::size.