/* This function should return a boolean (encoded as an int) indicating * whether or not a path exists between the argument vertices. * param: g Graph to perform the search in * param: source Vertex to originate the search from * param: destination Vertex to stop the search from (if it is found) * ret: boolean indicating whether or not a path exists */ int BFS(Graph* g, Vertex* source, Vertex* destination) { /* FIXME you will write this */ //use queue int contains = 0; struct cirListDeque *queue = malloc(sizeof(struct cirListDeque)); initCirListDeque(queue); clearVisited(g); struct Vertex *current; current = source; while(current != destination) { if(current->isVisited == 0) { current->isVisited = 1; for(int x = 0; x < current->numNeighbors; x++) { if(current->neighbors[x]->isVisited == 0) { addBackCirListDeque(queue, current->neighbors[x]); } } if(!isEmptyCirListDeque(queue)) { current = frontCirListDeque(queue); removeFrontCirListDeque(queue); } else return contains; } else { if(!isEmptyCirListDeque(queue)) { current = frontCirListDeque(queue); removeFrontCirListDeque(queue); } else return contains; } } if(current == destination) {contains = 1;} removeAllCirListDeque(queue); return contains; }
/* Reverse the deque param: q pointer to the deque pre: q is not null and q is not empty post: the deque is reversed */ void reverseCirListDeque(struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //declare an iterator struct DLink *i = q->Sentinel->next; //declare a temp for reversing links in chain struct DLink *temp = NULL; //reverse the next and prev pointers while(!EQ(i, q->Sentinel)) { temp = i->prev; i->prev = i->next; i->next = temp; i = i->prev; } //update sentinal aka change its first and next temp = q->Sentinel->next; q->Sentinel->next = q->Sentinel->prev; q->Sentinel->prev = temp; }
/* This function should return a boolean (encoded as an int) indicating * whether or not a path exists between the argument vertices. * param: g Graph to perform the search in * param: source Vertex to originate the search from * param: destination Vertex to stop the search from (if it is found) * ret: boolean indicating whether or not a path exists */ int BFS(Graph* g, Vertex* source, Vertex* destination) { /* FIXME you will write this */ struct cirListDeque *que = malloc(sizeof(struct cirListDeque)); struct Vertex *cur = malloc(sizeof(struct Vertex)); clearVisited(g); initCirListDeque(que); addFrontCirListDeque(que, source); while(!isEmptyCirListDeque(que)){ cur = frontCirListDeque(que); removeFrontCirListDeque(que); if(cur == destination){ return 1; } else if(!cur->isVisited){ int i; for(i=0; i<cur->numNeighbors; ++i){ if(!cur->neighbors[i]->isVisited){ addBackCirListDeque(que, cur->neighbors[i]); cur->neighbors[i]->isVisited = 1; } } cur->isVisited =1; } } return 0; }
/* Remove the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: the back is removed from the deque */ void removeBackCirListDeque(struct cirListDeque *q) { /* DONE: you must write this */ assert(q != 0 && !isEmptyCirListDeque(q)); _removeLink(q, q->Sentinel->prev); }
/* Remove the front of the deque param: q pointer to the deque pre: q is not null and q is not empty post: the front is removed from the deque */ void removeFrontCirListDeque (struct cirListDeque *q) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); _removeLink(q, q->Sentinel->next); }
/* Get the value of the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: none ret: value of the back of the deque */ TYPE backCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ /*temporary return value..you may need to change it*/ assert(!isEmptyCirListDeque(q)); return(q->Sentinel->prev->value); }
/* Get the value of the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: none ret: value of the back of the deque */ TYPE backCirListDeque(struct cirListDeque *q) { /* DONE: you must write this */ assert(q != 0 && !isEmptyCirListDeque(q)); /*temporary return value..you may need to change it*/ return q->Sentinel->prev->value; }
/* Remove the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: the back is removed from the deque */ void removeBackCirListDeque(struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //remove the last link _removeLink(q, q->Sentinel->prev); }
/* Get the value of the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: none ret: value of the back of the deque */ TYPE backCirListDeque(struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //return the value of the last link return (q->Sentinel->prev->value); }
/* Get the value of the front of the deque param: q pointer to the deque pre: q is not null and q is not empty post: none ret: value of the front of the deque */ TYPE frontCirListDeque(struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //return the value of the first link return (q->Sentinel->next->value); }
/* Remove a link from the deque param: q pointer to the deque param: lnk pointer to the link to be removed pre: q is not null and q is not empty post: the link is removed from the deque */ void _removeLink(struct cirListDeque *q, struct DLink *lnk) { /* DONE: you must write this */ assert(q != 0 && !isEmptyCirListDeque(q)); lnk->prev->next = lnk->next; lnk->next->prev = lnk->prev; free(lnk); q->size--; }
/* Get the value of the back of the deque param: q pointer to the deque pre: q is not null and q is not empty post: none ret: value of the back of the deque */ TYPE backCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ /* temporary return value..you may need to change it*/ /* return(1);*/ assert (q != 0); /* q is not null */ assert(!isEmptyCirListDeque(q)); /* q is not empty */ return q->Sentinel->prev->value; }
/* Remove the front of the deque param: q pointer to the deque pre: q is not null and q is not empty post: the front is removed from the deque */ void removeFrontCirListDeque (struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //remove the first link _removeLink(q, q->Sentinel->next); }
/* Adds a link after another link param: q pointer to the deque param: lnk pointer to the existing link in the deque param: newLnk pointer to the new link to add after the existing link pre: q is not null and q is not empty pre: lnk and newLnk are not null pre: lnk is in the deque post: the new link is added into the deque after the existing link */ void _addLinkAfter(struct cirListDeque *q, struct DLink *lnk, struct DLink *newLnk) { assert(!isEmptyCirListDeque(q)); /* re-allocate pointers */ newLnk->next = lnk->next; newLnk->prev = lnk; lnk->next->prev = newLnk; lnk->next = newLnk; /* increase the size of the deque */ q->size++; }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { /* DONE: you must write this */ assert(q != 0 && !isEmptyCirListDeque(q)); struct DLink *cursor = q->Sentinel->next; while (cursor != q->Sentinel){ printf("%g ", cursor->value); cursor = cursor->next; } printf("\n"); }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); struct DLink* printLink = q->Sentinel->next; while (printLink != q->Sentinel) { printf("%g\n", printLink->value); printLink = printLink->next; } }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { struct DLink *lnk; assert(!isEmptyCirListDeque(q)); lnk = q->last->next; do { printf("%f\n", lnk->value); lnk = lnk->next; } while(!EQ(lnk, q->last->next)); printf("+++++++++++\n"); }
/* Adds a link to the front of the deque param: q pointer to the deque param: val value for the link to be added pre: q is not null post: a link storing val is added to the front of the deque */ void addFrontCirListDeque(struct cirListDeque *q, TYPE val) { struct DLink * lnk = _createLink(val); if (isEmptyCirListDeque(q)) { /* if q is currently empty, the added link becomes the only link in the deque */ lnk->next = lnk; lnk->prev = lnk; q->size++; /* change last to the newly added link */ q->last = lnk; } else _addLinkAfter(q, q->last, lnk); }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); struct DLink * temp = q->Sentinel->next; printf("List Contains: "); while (temp != q->Sentinel) { printf("%g ", temp->value); temp = temp->next; } printf("\n"); }
/* Remove a link from the deque param: q pointer to the deque param: lnk pointer to the link to be removed pre: q is not null and q is not empty post: the link is removed from the deque */ void _removeLink(struct cirListDeque *q, struct DLink *lnk) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); lnk->next->prev = lnk->prev; lnk->prev->next = lnk->next; // Fee Allocated Memory free(lnk); // Decrese Size of Dequeue q->size--; }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ assert (q != 0); /* q is not null */ assert(!isEmptyCirListDeque(q)); /* q isn't empty */ struct DLink *tmp = q->Sentinel->next; /* iterator for moving thru links */ int i; for (i = 0; i < (q->size); i++) { printf(" %f\n", tmp->value); tmp = tmp->next; } printf("\n"); }
/* Print the links in the deque from front to back param: q pointer to the deque pre: q is not null and q is not empty post: the links in the deque are printed from front to back */ void printCirListDeque(struct cirListDeque *q) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //new iterator struct DLink *i = q->Sentinel->next; //while iterator has not reached the end of the linked list while(!EQ(i, q->Sentinel)) { printf("%g ", i->value); //print the value i = i->next; //update } printf("\n"); }
/* Remove a link from the deque param: q pointer to the deque param: lnk pointer to the link to be removed pre: q is not null and q is not empty post: the link is removed from the deque */ void _removeLink(struct cirListDeque *q, struct DLink *lnk) { //make sure q is not null assert(!EQ(q, 0)); //make sure q is not empty assert(!isEmptyCirListDeque(q)); //make sure chain does not break lnk->prev->next = lnk->next; lnk->next->prev = lnk->prev; //free link free(lnk); //decrement size q->size--; }
/* De-allocate all links of the deque param: q pointer to the deque pre: none post: All links (including Sentinel) are de-allocated */ void freeCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ /* first, make sure some things are true: */ assert (q != 0); /* q is not null */ assert(!isEmptyCirListDeque(q)); /* q isn't empty, yet */ assert(q->size != 0); /* q isn't empty, yet */ while (q->size > 0) { removeFrontCirListDeque(q); /* could also removeBack... */ /* q->size is decremented in _removeLink() */ } assert(q->size == 0); /* q should be empty now */ free (q->Sentinel); /* we are freeing Sent, not q (the deque) */ q->Sentinel = 0; /* just to be safe */ }
/* Reverse the deque param: q pointer to the deque pre: q is not null and q is not empty post: the deque is reversed */ void reverseCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); struct DLink * first = q->Sentinel; struct DLink * temp = q->Sentinel->next; int i; for (i = 0; i <= q->size; i++) { first->next = first->prev; first->prev = temp; first = temp; temp = temp->next; } }
/* Remove a link from the deque param: q pointer to the deque param: lnk pointer to the link to be removed pre: q is not null and q is not empty post: the link is removed from the deque */ void _removeLink(struct cirListDeque *q, struct DLink *lnk) { /* FIXME: you must write this */ assert (q != 0); /* q is not null */ assert(!isEmptyCirListDeque(q)); /* q is not empty */ /* make sure lnk is a thing that exists (not null and size !=0) */ assert (lnk != 0); assert (q->size != 0); /* connect lnk's neighbors before freeing lnk */ lnk->prev->next = lnk->next; lnk->next->prev = lnk->prev; free(lnk); /* free at last! */ q->size--; }
/* This function should return a boolean (encoded as an int) indicating * whether or not a path exists between the argument vertices. * param: g Graph to perform the search in * param: source Vertex to originate the search from * param: destination Vertex to stop the search from (if it is found) * ret: boolean indicating whether or not a path exists */ int BFS(Graph* g, Vertex* source, Vertex* destination){ /* FIXME you will write this */ /* create and initialize circular list deque pointer */ struct cirListDeque *stack = malloc(sizeof(struct cirListDeque)); initCirListDeque(stack); /*/ create vertex pointer and clear visited nodes */ struct Vertex *temp = source; clearVisited(g); /* add to front */ addFrontCirListDeque(stack, temp); /* if not empty, use BFS */ while(!isEmptyCirListDeque(stack)){ /*remove back(top) value */ temp = backCirListDeque(stack); removeBackCirListDeque(stack); /* check if visited, mark, and return true */ if(!temp -> isVisited){ temp -> isVisited = 1; } if(temp == destination){ removeAllCirListDeque(stack); return 1; } /* check is the neighboring nodes have been visited. add to stack if not */ for(int i = 0; i < temp->numNeighbors; i++){ if(!temp->neighbors[i]->isVisited){ addFrontCirListDeque(stack, temp->neighbors[i]); } } } return 0; }
/* Reverse the deque param: q pointer to the deque pre: q is not null and q is not empty post: the deque is reversed */ void reverseCirListDeque(struct cirListDeque *q) { /* FIXME: you must write this */ assert(q != 0); assert(!isEmptyCirListDeque(q)); struct DLink* test = q->Sentinel->next; struct DLink* testNext; while (test != q->Sentinel) { testNext = test->next; test->next = test->prev; test->prev = testNext; test = testNext; } testNext = q->Sentinel->next; q->Sentinel->next = q->Sentinel->prev; q->Sentinel->prev = testNext; }
/* Remove a link from the deque param: q pointer to the deque param: lnk pointer to the link to be removed pre: q is not null and q is not empty pre: lnk is in the deque post: the link is removed from the deque */ void _removeLink(struct cirListDeque *q, struct DLink *lnk) { assert(!isEmptyCirListDeque(q)); if (EQ(lnk, lnk->next)) { /* if lnk is the only link in the deque, set last to null */ q->last = 0; } else { lnk->next->prev = lnk->prev; lnk->prev->next = lnk->next; /* if lnk is the last link, change last to the previous of lnk */ if (EQ(lnk, q->last)) q->last = lnk->prev; } free(lnk); q->size--; }
/* Reverse the deque param: q pointer to the deque pre: q is not null and q is not empty post: the deque is reversed */ void reverseCirListDeque(struct cirListDeque *q) { /* DONE: you must write this */ assert(q != 0 && !isEmptyCirListDeque(q)); struct DLink *cursor = q->Sentinel; struct DLink *nextLink; struct DLink *swapTemp; do { //retrieve the next link before making any changes nextLink = cursor->next; //swap next and previous swapTemp = cursor->next; cursor->next = cursor->prev; cursor->prev = swapTemp; cursor = nextLink; } while (cursor != q->Sentinel); }