Implementation of a heap. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for container_heap.c:

Data Structures
struct	GNUNET_CONTAINER_HeapNode
	Node in the heap. More...

struct	GNUNET_CONTAINER_Heap
	Handle to a node in a heap. More...

Macros
#define	LOG(kind, ...)

#define	EXTRA_CHECKS 0

#define	CHECK(n) do {} while (0)

Functions
struct GNUNET_CONTAINER_Heap *	GNUNET_CONTAINER_heap_create (enum GNUNET_CONTAINER_HeapOrder order)
	Create a new heap. More...

void	GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
	Destroys the heap. More...

void *	GNUNET_CONTAINER_heap_peek (const struct GNUNET_CONTAINER_Heap *heap)
	Get element stored at the root of heap. More...

enum GNUNET_GenericReturnValue	GNUNET_CONTAINER_heap_peek2 (const struct GNUNET_CONTAINER_Heap heap, void element, GNUNET_CONTAINER_HeapCostType cost)
	Get element and cost stored at the root of heap. More...

unsigned int	GNUNET_CONTAINER_heap_get_size (const struct GNUNET_CONTAINER_Heap *heap)
	Get the current size of the heap. More...

GNUNET_CONTAINER_HeapCostType	GNUNET_CONTAINER_heap_node_get_cost (const struct GNUNET_CONTAINER_HeapNode *node)
	Get the current cost of the node. More...

static int	node_iterator (const struct GNUNET_CONTAINER_Heap heap, struct GNUNET_CONTAINER_HeapNode node, GNUNET_CONTAINER_HeapIterator iterator, void *iterator_cls)
	Iterate over the children of the given node. More...

void	GNUNET_CONTAINER_heap_iterate (const struct GNUNET_CONTAINER_Heap heap, GNUNET_CONTAINER_HeapIterator iterator, void iterator_cls)
	Iterate over all entries in the heap. More...

void *	GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *heap)
	Perform a random walk of the tree. More...

static void	insert_node (struct GNUNET_CONTAINER_Heap heap, struct GNUNET_CONTAINER_HeapNode pos, struct GNUNET_CONTAINER_HeapNode *node)
	Insert the given node 'node' into the subtree starting at 'pos' (while keeping the tree somewhat balanced). More...

struct GNUNET_CONTAINER_HeapNode *	GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap heap, void element, GNUNET_CONTAINER_HeapCostType cost)
	Inserts a new element into the heap. More...

void *	GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *heap)
	Remove root of the heap. More...

static void	remove_node (struct GNUNET_CONTAINER_HeapNode *node)
	Remove the given node 'node' from the tree and update the 'tree_size' fields accordingly. More...

void *	GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_HeapNode *node)
	Removes a node from the heap. More...

void	GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
	Updates the cost of any node in the tree. More...

Detailed Description

Implementation of a heap.

Author: Nathan Evans; Christian Grothoff

Definition in file container_heap.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)

Value:

GNUNET_log_from (kind, "util-container-heap", \

__VA_ARGS__)

GNUNET_log_from

#define GNUNET_log_from(kind, comp,...)

Definition: gnunet_common.h:536

Definition at line 32 of file container_heap.c.

◆ EXTRA_CHECKS

#define EXTRA_CHECKS 0

Definition at line 35 of file container_heap.c.

◆ CHECK

#define CHECK ( n ) do {} while (0)

Definition at line 129 of file container_heap.c.

Function Documentation

◆ node_iterator()

static int node_iterator	(	const struct GNUNET_CONTAINER_Heap *	heap,
		struct GNUNET_CONTAINER_HeapNode *	node,
		GNUNET_CONTAINER_HeapIterator	iterator,
		void *	iterator_cls
	)

static

Iterate over the children of the given node.

Parameters

heap	argument to give to iterator
node	node to iterate over
iterator	function to call on each node
iterator_cls	closure for iterator

Returns: GNUNET_YES to continue to iterate

Definition at line 210 of file container_heap.c.

{
  if (node == NULL)
    return GNUNET_YES;
  if (GNUNET_YES !=
      node_iterator (heap, node->left_child, iterator, iterator_cls))
    return GNUNET_NO;
  if (GNUNET_YES !=
      node_iterator (heap, node->right_child, iterator, iterator_cls))
    return GNUNET_NO;
  return iterator (iterator_cls, node, node->element, node->cost);
}

References GNUNET_CONTAINER_HeapNode::cost, GNUNET_CONTAINER_HeapNode::element, GNUNET_NO, GNUNET_YES, GNUNET_CONTAINER_HeapNode::left_child, node_iterator(), and GNUNET_CONTAINER_HeapNode::right_child.

Referenced by GNUNET_CONTAINER_heap_iterate(), and node_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_node()

static void insert_node	(	struct GNUNET_CONTAINER_Heap *	heap,
		struct GNUNET_CONTAINER_HeapNode *	pos,
		struct GNUNET_CONTAINER_HeapNode *	node
	)

static

Insert the given node 'node' into the subtree starting at 'pos' (while keeping the tree somewhat balanced).

Parameters

heap	heap to modify
pos	existing tree
node	node to insert (which may be a subtree itself)

Definition at line 264 of file container_heap.c.

{
  struct GNUNET_CONTAINER_HeapNode *parent;
 
  GNUNET_assert (node->parent == NULL);
  while ((heap->order == GNUNET_CONTAINER_HEAP_ORDER_MAX) ? (pos->cost >=
                                                             node->cost)
         : (pos->cost <= node->cost))
  {
    /* node is descendent of pos */
    pos->tree_size += (1 + node->tree_size);
    if (pos->left_child == NULL)
    {
      pos->left_child = node;
      node->parent = pos;
      return;
    }
    if (pos->right_child == NULL)
    {
      pos->right_child = node;
      node->parent = pos;
      return;
    }
    /* keep it balanced by descending into smaller subtree */
    if (pos->left_child->tree_size < pos->right_child->tree_size)
      pos = pos->left_child;
    else
      pos = pos->right_child;
  }
  /* make 'node' parent of 'pos' */
  parent = pos->parent;
  pos->parent = NULL;
  node->parent = parent;
  if (NULL == parent)
  {
    heap->root = node;
  }
  else
  {
    if (parent->left_child == pos)
      parent->left_child = node;
    else
      parent->right_child = node;
  }
  /* insert 'pos' below 'node' */
  insert_node (heap, node, pos);
  CHECK (pos);
}

References CHECK, GNUNET_CONTAINER_HeapNode::cost, GNUNET_assert, GNUNET_CONTAINER_HEAP_ORDER_MAX, GNUNET_CONTAINER_HeapNode::heap, insert_node(), GNUNET_CONTAINER_HeapNode::left_child, GNUNET_CONTAINER_Heap::order, GNUNET_CONTAINER_HeapNode::parent, GNUNET_CONTAINER_HeapNode::right_child, GNUNET_CONTAINER_Heap::root, and GNUNET_CONTAINER_HeapNode::tree_size.

Referenced by GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_heap_update_cost(), insert_node(), and remove_node().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_node()

static void remove_node ( struct GNUNET_CONTAINER_HeapNode * node )

static

Remove the given node 'node' from the tree and update the 'tree_size' fields accordingly.

Preserves the children of 'node' and does NOT change the overall 'size' field of the tree.

Definition at line 390 of file container_heap.c.

{
  struct GNUNET_CONTAINER_HeapNode *ancestor;
  struct GNUNET_CONTAINER_Heap *heap = node->heap;
 
  /* update 'size' of the ancestors */
  ancestor = node;
  while (NULL != (ancestor = ancestor->parent))
    ancestor->tree_size--;
 
  /* update 'size' of node itself */
  if (node->left_child != NULL)
    node->tree_size -= (1 + node->left_child->tree_size);
  if (node->right_child != NULL)
    node->tree_size -= (1 + node->right_child->tree_size);
 
  /* unlink 'node' itself and insert children in its place */
  if (node->parent == NULL)
  {
    if (node->left_child != NULL)
    {
      heap->root = node->left_child;
      node->left_child->parent = NULL;
      if (node->right_child != NULL)
      {
        node->right_child->parent = NULL;
        insert_node (heap, heap->root, node->right_child);
      }
    }
    else
    {
      heap->root = node->right_child;
      if (node->right_child != NULL)
        node->right_child->parent = NULL;
    }
  }
  else
  {
    if (node->parent->left_child == node)
      node->parent->left_child = NULL;
    else
      node->parent->right_child = NULL;
    if (node->left_child != NULL)
    {
      node->left_child->parent = NULL;
      node->parent->tree_size -= (1 + node->left_child->tree_size);
      insert_node (heap, node->parent, node->left_child);
    }
    if (node->right_child != NULL)
    {
      node->right_child->parent = NULL;
      node->parent->tree_size -= (1 + node->right_child->tree_size);
      insert_node (heap, node->parent, node->right_child);
    }
  }
  node->parent = NULL;
  node->left_child = NULL;
  node->right_child = NULL;
  GNUNET_assert (node->tree_size == 0);
  CHECK (heap->root);
}

References CHECK, GNUNET_assert, GNUNET_CONTAINER_HeapNode::heap, insert_node(), GNUNET_CONTAINER_HeapNode::left_child, GNUNET_CONTAINER_HeapNode::parent, GNUNET_CONTAINER_HeapNode::right_child, GNUNET_CONTAINER_Heap::root, and GNUNET_CONTAINER_HeapNode::tree_size.

Referenced by GNUNET_CONTAINER_heap_remove_node(), and GNUNET_CONTAINER_heap_update_cost().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

◆ EXTRA_CHECKS

◆ CHECK

Function Documentation

◆ node_iterator()

◆ insert_node()

◆ remove_node()