URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [libiberty/] [fibheap.c] - Rev 250
Go to most recent revision | Compare with Previous | Blame | View Log
/* A Fibonacci heap datatype. Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc. Contributed by Daniel Berlin (dan@cgsoftware.com). This file is part of GNU CC. GNU CC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU CC; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_LIMITS_H #include <limits.h> #endif #ifdef HAVE_STDLIB_H #include <stdlib.h> #endif #ifdef HAVE_STRING_H #include <string.h> #endif #include "libiberty.h" #include "fibheap.h" #define FIBHEAPKEY_MIN LONG_MIN static void fibheap_ins_root (fibheap_t, fibnode_t); static void fibheap_rem_root (fibheap_t, fibnode_t); static void fibheap_consolidate (fibheap_t); static void fibheap_link (fibheap_t, fibnode_t, fibnode_t); static void fibheap_cut (fibheap_t, fibnode_t, fibnode_t); static void fibheap_cascading_cut (fibheap_t, fibnode_t); static fibnode_t fibheap_extr_min_node (fibheap_t); static int fibheap_compare (fibheap_t, fibnode_t, fibnode_t); static int fibheap_comp_data (fibheap_t, fibheapkey_t, void *, fibnode_t); static fibnode_t fibnode_new (void); static void fibnode_insert_after (fibnode_t, fibnode_t); #define fibnode_insert_before(a, b) fibnode_insert_after (a->left, b) static fibnode_t fibnode_remove (fibnode_t); /* Create a new fibonacci heap. */ fibheap_t fibheap_new (void) { return (fibheap_t) xcalloc (1, sizeof (struct fibheap)); } /* Create a new fibonacci heap node. */ static fibnode_t fibnode_new (void) { fibnode_t node; node = (fibnode_t) xcalloc (1, sizeof *node); node->left = node; node->right = node; return node; } static inline int fibheap_compare (fibheap_t heap ATTRIBUTE_UNUSED, fibnode_t a, fibnode_t b) { if (a->key < b->key) return -1; if (a->key > b->key) return 1; return 0; } static inline int fibheap_comp_data (fibheap_t heap, fibheapkey_t key, void *data, fibnode_t b) { struct fibnode a; a.key = key; a.data = data; return fibheap_compare (heap, &a, b); } /* Insert DATA, with priority KEY, into HEAP. */ fibnode_t fibheap_insert (fibheap_t heap, fibheapkey_t key, void *data) { fibnode_t node; /* Create the new node. */ node = fibnode_new (); /* Set the node's data. */ node->data = data; node->key = key; /* Insert it into the root list. */ fibheap_ins_root (heap, node); /* If their was no minimum, or this key is less than the min, it's the new min. */ if (heap->min == NULL || node->key < heap->min->key) heap->min = node; heap->nodes++; return node; } /* Return the data of the minimum node (if we know it). */ void * fibheap_min (fibheap_t heap) { /* If there is no min, we can't easily return it. */ if (heap->min == NULL) return NULL; return heap->min->data; } /* Return the key of the minimum node (if we know it). */ fibheapkey_t fibheap_min_key (fibheap_t heap) { /* If there is no min, we can't easily return it. */ if (heap->min == NULL) return 0; return heap->min->key; } /* Union HEAPA and HEAPB into a new heap. */ fibheap_t fibheap_union (fibheap_t heapa, fibheap_t heapb) { fibnode_t a_root, b_root, temp; /* If one of the heaps is empty, the union is just the other heap. */ if ((a_root = heapa->root) == NULL) { free (heapa); return heapb; } if ((b_root = heapb->root) == NULL) { free (heapb); return heapa; } /* Merge them to the next nodes on the opposite chain. */ a_root->left->right = b_root; b_root->left->right = a_root; temp = a_root->left; a_root->left = b_root->left; b_root->left = temp; heapa->nodes += heapb->nodes; /* And set the new minimum, if it's changed. */ if (fibheap_compare (heapa, heapb->min, heapa->min) < 0) heapa->min = heapb->min; free (heapb); return heapa; } /* Extract the data of the minimum node from HEAP. */ void * fibheap_extract_min (fibheap_t heap) { fibnode_t z; void *ret = NULL; /* If we don't have a min set, it means we have no nodes. */ if (heap->min != NULL) { /* Otherwise, extract the min node, free the node, and return the node's data. */ z = fibheap_extr_min_node (heap); ret = z->data; free (z); } return ret; } /* Replace both the KEY and the DATA associated with NODE. */ void * fibheap_replace_key_data (fibheap_t heap, fibnode_t node, fibheapkey_t key, void *data) { void *odata; fibheapkey_t okey; fibnode_t y; /* If we wanted to, we could actually do a real increase by redeleting and inserting. However, this would require O (log n) time. So just bail out for now. */ if (fibheap_comp_data (heap, key, data, node) > 0) return NULL; odata = node->data; okey = node->key; node->data = data; node->key = key; y = node->parent; /* Short-circuit if the key is the same, as we then don't have to do anything. Except if we're trying to force the new node to be the new minimum for delete. */ if (okey == key && okey != FIBHEAPKEY_MIN) return odata; /* These two compares are specifically <= 0 to make sure that in the case of equality, a node we replaced the data on, becomes the new min. This is needed so that delete's call to extractmin gets the right node. */ if (y != NULL && fibheap_compare (heap, node, y) <= 0) { fibheap_cut (heap, node, y); fibheap_cascading_cut (heap, y); } if (fibheap_compare (heap, node, heap->min) <= 0) heap->min = node; return odata; } /* Replace the DATA associated with NODE. */ void * fibheap_replace_data (fibheap_t heap, fibnode_t node, void *data) { return fibheap_replace_key_data (heap, node, node->key, data); } /* Replace the KEY associated with NODE. */ fibheapkey_t fibheap_replace_key (fibheap_t heap, fibnode_t node, fibheapkey_t key) { int okey = node->key; fibheap_replace_key_data (heap, node, key, node->data); return okey; } /* Delete NODE from HEAP. */ void * fibheap_delete_node (fibheap_t heap, fibnode_t node) { void *ret = node->data; /* To perform delete, we just make it the min key, and extract. */ fibheap_replace_key (heap, node, FIBHEAPKEY_MIN); if (node != heap->min) { fprintf (stderr, "Can't force minimum on fibheap.\n"); abort (); } fibheap_extract_min (heap); return ret; } /* Delete HEAP. */ void fibheap_delete (fibheap_t heap) { while (heap->min != NULL) free (fibheap_extr_min_node (heap)); free (heap); } /* Determine if HEAP is empty. */ int fibheap_empty (fibheap_t heap) { return heap->nodes == 0; } /* Extract the minimum node of the heap. */ static fibnode_t fibheap_extr_min_node (fibheap_t heap) { fibnode_t ret = heap->min; fibnode_t x, y, orig; /* Attach the child list of the minimum node to the root list of the heap. If there is no child list, we don't do squat. */ for (x = ret->child, orig = NULL; x != orig && x != NULL; x = y) { if (orig == NULL) orig = x; y = x->right; x->parent = NULL; fibheap_ins_root (heap, x); } /* Remove the old root. */ fibheap_rem_root (heap, ret); heap->nodes--; /* If we are left with no nodes, then the min is NULL. */ if (heap->nodes == 0) heap->min = NULL; else { /* Otherwise, consolidate to find new minimum, as well as do the reorg work that needs to be done. */ heap->min = ret->right; fibheap_consolidate (heap); } return ret; } /* Insert NODE into the root list of HEAP. */ static void fibheap_ins_root (fibheap_t heap, fibnode_t node) { /* If the heap is currently empty, the new node becomes the singleton circular root list. */ if (heap->root == NULL) { heap->root = node; node->left = node; node->right = node; return; } /* Otherwise, insert it in the circular root list between the root and it's right node. */ fibnode_insert_after (heap->root, node); } /* Remove NODE from the rootlist of HEAP. */ static void fibheap_rem_root (fibheap_t heap, fibnode_t node) { if (node->left == node) heap->root = NULL; else heap->root = fibnode_remove (node); } /* Consolidate the heap. */ static void fibheap_consolidate (fibheap_t heap) { fibnode_t a[1 + 8 * sizeof (long)]; fibnode_t w; fibnode_t y; fibnode_t x; int i; int d; int D; D = 1 + 8 * sizeof (long); memset (a, 0, sizeof (fibnode_t) * D); while ((w = heap->root) != NULL) { x = w; fibheap_rem_root (heap, w); d = x->degree; while (a[d] != NULL) { y = a[d]; if (fibheap_compare (heap, x, y) > 0) { fibnode_t temp; temp = x; x = y; y = temp; } fibheap_link (heap, y, x); a[d] = NULL; d++; } a[d] = x; } heap->min = NULL; for (i = 0; i < D; i++) if (a[i] != NULL) { fibheap_ins_root (heap, a[i]); if (heap->min == NULL || fibheap_compare (heap, a[i], heap->min) < 0) heap->min = a[i]; } } /* Make NODE a child of PARENT. */ static void fibheap_link (fibheap_t heap ATTRIBUTE_UNUSED, fibnode_t node, fibnode_t parent) { if (parent->child == NULL) parent->child = node; else fibnode_insert_before (parent->child, node); node->parent = parent; parent->degree++; node->mark = 0; } /* Remove NODE from PARENT's child list. */ static void fibheap_cut (fibheap_t heap, fibnode_t node, fibnode_t parent) { fibnode_remove (node); parent->degree--; fibheap_ins_root (heap, node); node->parent = NULL; node->mark = 0; } static void fibheap_cascading_cut (fibheap_t heap, fibnode_t y) { fibnode_t z; while ((z = y->parent) != NULL) { if (y->mark == 0) { y->mark = 1; return; } else { fibheap_cut (heap, y, z); y = z; } } } static void fibnode_insert_after (fibnode_t a, fibnode_t b) { if (a == a->right) { a->right = b; a->left = b; b->right = a; b->left = a; } else { b->right = a->right; a->right->left = b; a->right = b; b->left = a; } } static fibnode_t fibnode_remove (fibnode_t node) { fibnode_t ret; if (node == node->left) ret = NULL; else ret = node->left; if (node->parent != NULL && node->parent->child == node) node->parent->child = ret; node->right->left = node->left; node->left->right = node->right; node->parent = NULL; node->left = node; node->right = node; return ret; }
Go to most recent revision | Compare with Previous | Blame | View Log