priorityq-heap.h File Reference

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

Go to the source code of this file.

Classes
struct	PQnode
struct	PQhandleElem
struct	PriorityQ

Macros
#define	PQkey   PQHeapKey
#define	PQhandle   PQHeapHandle
#define	PriorityQ   PriorityQHeap
#define	pqNewPriorityQ(leq)   __gl_pqHeapNewPriorityQ(leq)
#define	pqDeletePriorityQ(pq)   __gl_pqHeapDeletePriorityQ(pq)
#define	pqInit(pq)   __gl_pqHeapInit(pq)
#define	pqInsert(pq, key)   __gl_pqHeapInsert(pq,key)
#define	pqMinimum(pq)   __gl_pqHeapMinimum(pq)
#define	pqExtractMin(pq)   __gl_pqHeapExtractMin(pq)
#define	pqDelete(pq, handle)   __gl_pqHeapDelete(pq,handle)
#define	pqIsEmpty(pq)   __gl_pqHeapIsEmpty(pq)
#define	__gl_pqHeapMinimum(pq)   ((pq)->handles[(pq)->nodes[1].handle].key)
#define	__gl_pqHeapIsEmpty(pq)   ((pq)->size == 0)

Typedefs
typedef void *	PQkey
typedef long	PQhandle
typedef struct PriorityQ	PriorityQ

Functions
PriorityQ *	pqNewPriorityQ (int(*leq)(PQkey key1, PQkey key2))
void	pqDeletePriorityQ (PriorityQ *pq)
void	pqInit (PriorityQ *pq)
PQhandle	pqInsert (PriorityQ *pq, PQkey key)
PQkey	pqExtractMin (PriorityQ *pq)
void	pqDelete (PriorityQ *pq, PQhandle handle)

Macro Definition Documentation

__gl_pqHeapIsEmpty

#define __gl_pqHeapIsEmpty

(

pq

)

((pq)->size == 0)

Definition at line 105 of file priorityq-heap.h.

__gl_pqHeapMinimum

#define __gl_pqHeapMinimum

(

pq

)

((pq)->handles[(pq)->nodes[1].handle].key)

Definition at line 104 of file priorityq-heap.h.

pqDelete

#define pqDelete	(		pq,
			handle
	)		__gl_pqHeapDelete(pq,handle)

Definition at line 64 of file priorityq-heap.h.

pqDeletePriorityQ

#define pqDeletePriorityQ

(

pq

)

__gl_pqHeapDeletePriorityQ(pq)

Definition at line 45 of file priorityq-heap.h.

pqExtractMin

#define pqExtractMin

(

pq

)

__gl_pqHeapExtractMin(pq)

Definition at line 63 of file priorityq-heap.h.

PQhandle

#define PQhandle   PQHeapHandle

Definition at line 41 of file priorityq-heap.h.

pqInit

#define pqInit

(

pq

)

__gl_pqHeapInit(pq)

Definition at line 60 of file priorityq-heap.h.

pqInsert

#define pqInsert	(		pq,
			key
	)		__gl_pqHeapInsert(pq,key)

Definition at line 61 of file priorityq-heap.h.

pqIsEmpty

#define pqIsEmpty

(

pq

)

__gl_pqHeapIsEmpty(pq)

Definition at line 65 of file priorityq-heap.h.

PQkey

#define PQkey   PQHeapKey

Definition at line 40 of file priorityq-heap.h.

pqMinimum

#define pqMinimum

(

pq

)

__gl_pqHeapMinimum(pq)

Definition at line 62 of file priorityq-heap.h.

pqNewPriorityQ

#define pqNewPriorityQ

(

leq

)

__gl_pqHeapNewPriorityQ(leq)

Definition at line 44 of file priorityq-heap.h.

PriorityQ

#define PriorityQ   PriorityQHeap

Definition at line 42 of file priorityq-heap.h.

Typedef Documentation

PQhandle

typedef long PQhandle

Definition at line 80 of file priorityq-heap.h.

PQkey

typedef void* PQkey

Definition at line 79 of file priorityq-heap.h.

PriorityQ

typedef struct PriorityQ PriorityQ

Definition at line 81 of file priorityq-heap.h.

Function Documentation

pqDelete()

void pqDelete	(	PriorityQ *	pq,
		PQhandle	handle
	)

Definition at line 234 of file priorityq-heap.c.

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

pqDeletePriorityQ()

void pqDeletePriorityQ

(

PriorityQ *

pq

)

Definition at line 88 of file priorityq-heap.c.

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

pqExtractMin()

PQkey pqExtractMin

(

PriorityQ *

pq

)

Definition at line 211 of file priorityq-heap.c.

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

pqInit()

void pqInit

(

PriorityQ *

pq

)

Definition at line 149 of file priorityq-heap.c.

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

pqInsert()

PQhandle pqInsert	(	PriorityQ *	pq,
		PQkey	key
	)

Definition at line 163 of file priorityq-heap.c.

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

pqNewPriorityQ()

PriorityQ * pqNewPriorityQ

(

int(*)(PQkey key1, PQkey key2)

leq

)

Definition at line 58 of file priorityq-heap.c.

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