void dequeAddFront(deque_p d, TYPE val) { if(d->size >= d->cap) { putchar('\n'); printf("Doubling after call to dequeAddFront...\n"); printf("current contents:\n"); printDeque(d); putchar('\n'); _dequeDoubleCap(d); } // Get pointer to front of deque. TYPE* front = dequeFront(d); // If the pointer to the front is the beginning // of the array, set d->beg to d->cap and // reset front to point to the next address // after the end of the array if(front == d->data) { d->beg = d->cap; front = &(d->data[d->cap]); } d->beg--; *(--front) = val; d->size++; }
//add a leaf to the tree. heap must stay complete at all times. void addLeaf(heap *h,data *d) { //We already have code from binary trees that we can use to //fill the heap completely, this should closely mirror that code //If the heap is empty if(h->root == NULL) { //Create a new leaf to put in the heap leaf* new_leaf = createLeaf(d); //Set the root to be the new leaf. //Note that left, right and parent are all already appropriately set for the root node h->root = new_leaf; //This is definitely a heap, as it contains only one node. dequePushFront(h->q, new_leaf); } //If the heap is not empty else { //Then our node will get linked to the first node in the deque (previously this was a queue) leaf* parent = dequeFront(h->q); //If the parent does not have a left child, then this new node becomes the left child if(parent->left == NULL) { //Create a new leaf, and link it in appropriately leaf* new_leaf = createLeaf(d); new_leaf->parent = parent; parent->left = new_leaf; //Enqueue the leaf dequePushBack(h->q, new_leaf); //Now we may have violated the max-heap property, we can fix this by using percolate up percolateUp(new_leaf); } //Otherwise the parent node should only have space in the right child else { //Just to be sure that the left child was non-null assert(parent->left != NULL && parent->right == NULL); //Create a new leaf, and link it in appropriately leaf* new_leaf = createLeaf(d); new_leaf->parent = parent; parent->right = new_leaf; //Enqueue the leaf dequePushBack(h->q, new_leaf); //Now the front of the deque does not have any more space, so remove it dequePopFront(h->q); //Now we may have violated the max-heap property, we can fix this by using percolate up percolateUp(new_leaf); } } return; }
/** * Determines if there is a path from the source to the destination using an * iterative breadth-first search starting at the source. * * Remember to call clearVisited() before starting the search. * * @param graph * @param source * @param destination * @return 1 if there is a path, 0 otherwise. */ int bfsIterative(Graph* graph, Vertex* source, Vertex* destination) { clearVisited(graph); int i; int found = 0; // queue Deque *collection = malloc(sizeof(Deque)); Vertex *current; // initialize queue and add source collection = dequeNew(); dequePushBack(collection, source); // search until destination is found or we run out of edges while (!(found == 1) && !dequeIsEmpty(collection)) { // current vertex is the one first added to collection current = dequeFront(collection); dequePopFront(collection); current->isVisited = 1; // if the current node is the destination, we're done if (current == destination) found = 1; // otherwise add its neighbors to the queue else { for (i = 0; i < current->numNeighbors; ++i) if (!(current->neighbors[i]->isVisited)) dequePushBack(collection, current->neighbors[i]); } } // clean things up clearVisited(graph); dequeClear(collection); free(collection); // return if path was found return found; }
void dequeAddFront(deque_p d, TYPE val) { if(d->size >= d->cap) _dequeDoubleCap(d); // Get pointer to front of deque. TYPE* front = dequeFront(d); // If the pointer to the front is the beginning // of the array, set d->beg to d->cap and // reset front to point to the next address // after the end of the array if(front == d->data) { d->beg = d->cap; front = &(d->data[d->cap]); } d->beg--; *(--front) = val; d->size++; }