Type CTECList<Type>:: removeFromIndex(int index)
{
Type thingToRemove;
assert(size > 0);
assert(index >= 0);
assert(index < size);
assert(size > 0 && index >= 0 && index < size); //Same as the three above
ArrayNode<Type> * previous, deleteMe, newNext;
if(index == 0)
{
thingToRemove = removeFromFront();
}
else if(index == size - 1)
{
thingToRemove = removeFromEnd();
}
else
{
for(int spot = 0; spot < index + 1; spot++)
{
}
}
this -> calculateSize();
return thingToRemove;
}
Type CTECList<Type>::removeFromEnd()
{
//defencive code
assert(this->size > 0);
Type returnValue;
ArrayNode<Type> * newTail = new ArrayNode<Type>();
ArrayNode<Type> * current = ArrayNode<Type>();
if(size == 1)
{
ArrayNode<Type> * toRemove = tail;
returnValue = removeFromFront();
tail = nullptr;
}
else
{
ArrayNode<Type> * current = head;
for(int index = 0; index < size-1; index ++)
{
current = current->getNext();
}
returnValue = tail->getValue();
delete tail;
current = newTail;
calculateSize();
current->setNext(nullptr);
}
return returnValue;
}
Type CTECList<Type>::removeFromBack()
{
assert(size > 0);
Type returnValue;
if(size == 1)
{
ArrayNode<Type> * toRemove = end;
returnValue = removeFromFront();
end = nullptr;
head = nullptr;
delete toRemove;
}
else
{
ArrayNode<Type> * current = head;
for(int index = 0; index < size - 1; index++)
{
current = current->getNext();
}
returnValue = end->getValue();
delete end;
current = end;
current->setNext(nullptr);
}
calculateSize();
return returnValue;
}
int pop(Stack * stack)
{
int removedElement;
removedElement = firstValue(stack -> top);
removeFromFront(stack -> top);
return(removedElement);
}
// Function to insert a new node in complete binary tree
void treeInsert(struct node **root, int data, struct Queue *queue)
{
// Create a new node for give data
struct node *temp = newNode(data);
// If the tree is empty, initialize the root with a new node
if (!*root)
*root = temp;
else
{
// get the front node of the queue
struct node *front = getFront(queue);
// If the left child of this front node doesn't exist,
// set the left child as the new node
if (!front->left)
front->left = temp;
// If the right child of this front node doesn't exist;
// set the right child as the new node
else if (!front->right)
front->right = temp;
// If the front node has both children, dequeue it
if (hasBothChildren(front))
removeFromFront(queue);
}
// Enqueue the new node for later insertions
enqueue(temp, queue);
}
bool List :: removeFromList( char value )
{
ListNode *deletePtr; // Pointer will point to node will be deleted
ListNode *prevPtr; // Pointer that will point to previous node
deletePtr = firstPtr;
while( deletePtr != NULL ) // Traverse through the list
{
if( deletePtr->data != value ) // Matching pointer data with value
{
deletePtr = deletePtr->nextPtr;
}
else
break;
}
if( deletePtr == NULL )
{
cout << endl << "That node is not in the list." << endl << endl;
return false;
}
prevPtr = firstPtr;
if( deletePtr == firstPtr )
{
// Calling removeFromFront if user wants to delete first node
removeFromFront();
return true;
}
if( deletePtr == firstPtr ) // if one element remains
{
if ( firstPtr == lastPtr )
firstPtr = lastPtr = NULL; // no nodes remain after removal
delete deletePtr; // reclaim previous front node
return true; // delete successful
}
while( prevPtr->nextPtr != deletePtr )
{
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = deletePtr->nextPtr;
delete deletePtr;
return true;
} // end function removeFromList
Type CTECList<Type> :: removeFromIndex(int index)
{
assert(this->size > 0);
assert(index >= 0 && index < size);
Type thingToRemove;
Arraynode<Type> * previous,deleteMe,newNext;
if(index == 0)
{
thingToRemove = removeFromFront();
}
else if(index == size-1)
{
thingToRemove = removeFromEnd();
p
}
// Standard level-order traversal to test
void levelOrder(struct node *root)
{
struct Queue *queue = createQueue(SIZE);
enqueue(root, queue);
while (!queueIsEmpty(queue))
{
struct node *temp = removeFromFront(queue);
printf("%d\n", temp->data);
if (temp->left)
//printf("adding temp->left to queue\n");
enqueue(temp->left, queue);
if (temp->right)
//printf("adding temp->right to queue\n");
enqueue(temp->right, queue);
}
}
Type CTECList<Type>:: removeFromEnd()
{
//Check for size == 1 it is a special case
//Loop over size
//or
//Loop until getNext()->getNext() == nullptr.
//Grab the value from the last node
//set the next to last node as end
//delete the old last node
//Before return the variable call calculateSize().
assert(size > 0);
Type thingToRemove;
if(size == 1)
{
thingToRemove = removeFromFront();
end = nullptr;
calculateSize();
return thingToRemove;
}
else
{
ArrayNode<Type> * current = head;
for(int spot = 0; spot < size -1; spot++)
{
current = current -> getNext();
}
//Another way to do this
// ArrayNode<Type> * pointer = head;
// while(pointer -> getNext() -> getNext() != nullptr)
// {
// pointer = pointer -> getNext();
// }
thingToRemove = current -> getNext() -> getValue();
end = current;
delete current -> getNext();
this -> calculateSize();
return thingToRemove;
}
}
Type CTECList<Type>::removeFromIndex(int index)
{
assert(index >= 0);
assert(index < size);
assert(size > 0);
ArrayNode<Type> * deleteMe = new ArrayNode<Type>();
Type thingToRemove;
ArrayNode<Type> * newNext = new ArrayNode<Type>();
ArrayNode<Type> * current = new ArrayNode<Type>();
ArrayNode<Type> * previous = new ArrayNode<Type>();
if(index == 0)
{
thingToRemove = removeFromFront();
}
else if(index == size-1)
{
thingToRemove = removeFromEnd();
}
else
{
for(int index = 0; index < size ; index++)
{
current = current->next();
}
ArrayNode<Type> * previous = newNext;
delete deleteMe;
this->calculateSize;
return deleteMe;
}
}
// main crawler function
int main(int argc, char* argv[]) {
// local variables
FILE *fp; // file pointer for html files
char *nextURL; // pointer to the next URL found on the seed page
char *newURL; // pointer to the next URL in the while loop
// check command line arguments
if (argc != 4) {
printf("Incorrect number of arguments provided.");
exit(1);
}
// check that the second argument is a directory
stat(argv[2],&statbuffer);
if S_ISDIR(statbuffer.st_mode) { }
else {
printf("Error, you did not supply a valid directory");
exit(1);
}
// get arguments
char *seedURL = argv[1];
int filename_len = strlen(argv[2])+21;
// get the directory
char*filename = calloc(filename_len,sizeof(char));
// check the maxDepth
int value = is_numeric(argv[3]);
if (value != 0) {
sscanf(argv[3],"%i",&maxDepth);
}
else {
printf("Error! maxDepth must be a number");
exit(1);
}
// init curl
curl_global_init(CURL_GLOBAL_ALL);
// initialize data structures/variables
// initialize hashtable
HashTable *table = malloc(sizeof(HashTable));
memset(table,0,MAX_HASH_SLOT);
// initialize linked list
List *WebPageList;
WebPageList = createList();
// setup seed page
// get seed webpage
// if it fails, report and exit
if (NormalizeURL(seedURL) == 0) {
printf("Error, bad URL");
exit(1);
}
// write seed file
// create WebPage object by allocating memory
WebPage *seedPage = malloc(sizeof(WebPage));
// assign values to each part of the struct
seedPage->url = seedURL;
seedPage->html = NULL;
seedPage->html_len = 0;
seedPage->depth = 0;
// try to get the webpage up to MAX_TRY times
if (!GetWebPage(seedPage)) {
for (tries = 0; tries < MAX_TRY; tries++) {
if (GetWebPage(seedPage)) {
break;
}
}
}
// write html contents to a file "1" in the given directory
sprintf(filename,"%s/%d",argv[2],1);
fp = fopen(filename,"w");
fputs(seedURL,fp);
fputs("\n",fp);
fprintf(fp,"%d\n",seedPage->depth);
fputs(seedPage->html,fp);
// close the file and wipe the filename
fclose(fp);
memset(filename,'\0',filename_len);
// add seed page to hashtable
add(table,seedURL);
// extract urls from seed page
// while there are still URLs in the seed page's html
while ((pos = GetNextURL(seedPage->html,pos,seedPage->url,&nextURL)) > 0) {
// only visiting them if it wouldn't exceed maxDepth
if ((seedPage->depth+1) > maxDepth) {
free(seedPage);
exit(1);
}
// ensure it's a valid url
if (NormalizeURL(nextURL) != 0) {
// also check if its in the right domain
if (strncmp(URL_PREFIX,nextURL,strlen(URL_PREFIX)) == 0) {
// if it is added to the hashtable it is a unique URL that
// hasn't been visited before, add it to the linked list
// of URLs to visit
if (add(table,nextURL)) {
// create a new webpage object
WebPage *pages = malloc(sizeof(WebPage));
pages->url = nextURL;
pages->html = NULL;
pages->html_len = 0;
pages->depth = 1;
// try to get the webpage up until the MAX_TRY
tries = 0;
if (!GetWebPage(pages)) {
for (tries = 0; tries < MAX_TRY; tries++) {
if (GetWebPage(pages)) {
break;
}
}
}
// add it to the linked list
addToEnd(WebPageList,pages);
}
}
}
}
// while there are urls to crawl
while (WebPageList->head != NULL) {
// get next url from list
WebPage *nextPage = malloc(sizeof(WebPage));
nextPage = removeFromFront(WebPageList);
// try to get the webpage up until the MAX_TRY
tries = 0;
if (!GetWebPage(nextPage)) {
for (tries = 0; tries < MAX_TRY; tries++) {
if (GetWebPage(nextPage)) {
break;
}
}
}
// write page file
sprintf(filename,"%s/%d",argv[2],docNum);
fp = fopen(filename,"w");
fputs(nextPage->url,fp);
fputs("\n",fp);
fprintf(fp,"%d\n",nextPage->depth);
fputs(nextPage->html,fp);
// close the file and wipe the filename (to be used next time)
fclose(fp);
memset(filename,'\0',filename_len);
// increment the doc num
docNum++;
// check if visiting the URLs on this page will exceed maxDepth
if ((nextPage->depth+1) > maxDepth) {
free(nextPage);
continue;
}
pos = 0;
// iterate through all the URLs on the page
while ((pos = GetNextURL(nextPage->html,pos,nextPage->url,&newURL))>0) {
// check to ensure that the URLs are the proper format
if (NormalizeURL(newURL) != 0 ) {
// check to ensure that they are in the right domain
if (strncmp(URL_PREFIX,newURL,strlen(URL_PREFIX)) == 0) {
// making sure to only add new ones to the list
if (add(table,newURL) != 0) {
// create a new WebPage object
WebPage *page = malloc(sizeof(WebPage));
page->url = newURL;
page->html = NULL;
page->html_len = 0;
page->depth = nextPage->depth + 1;
GetWebPage(page);
// try to get the webpage up until the MAX_TRY
tries = 0;
if (!GetWebPage(page)) {
for (tries = 0; tries < MAX_TRY; tries++) {
if (GetWebPage(page)) {
break;
}
}
}
// add the page to the linked list
addToEnd(WebPageList,page);
}
}
}
}
// Sleep for a bit to avoid annoying the target
sleep(INTERVAL_PER_FETCH);
// Free resources
free(nextPage);
}
// cleanup curl
curl_global_cleanup();
// free resources
// free hashtable
hash = JenkinsHash(seedURL,MAX_HASH_SLOT);
HashTableNode *freer = table->table[hash];
HashTableNode *tempHash = NULL;
while (freer != NULL) {
tempHash = freer;
freer = freer->next;
free(tempHash);
}
free(table);
// free linked list
free(WebPageList);
// free WebPage and filename pointer
free(seedPage);
free(filename);
return 0;
}
// Heap things go here
void maxHeapify(struct node *root)
{
struct Queue *queue = createQueue(SIZE);
enqueue(root, queue);
while (!queueIsEmpty(queue))
{
struct node *temp = removeFromFront(queue);
/*
printf("Dequeue'd node->data: %d\n",temp->data);
// If left > data AND left > right, replace data with left
if ((temp->left->data > temp->data) && (temp->left->data > temp->right->data))
{
printf("Left child %d was greater than %d. Moving %d to back of queue...\n", temp->left->data, temp->data, temp->data);
struct node *swapA = newNode(temp->left->data);
printf("swapA->data = %d\n", swapA->data);
if (temp->left)
{
swapA->left = temp;
printf("temp->left copied to swapA->left. swapA->left value is %d\n", swapA->left->data);
}
if (temp->right)
{
swapA->right = temp->right;
printf("temp->right copied to swapA->right. swapA->right value is %d\n", swapA->right->data);
}
temp->data = temp->left->data;
printf("New temp->data: %d\n", temp->data);
enqueue(swapA, queue);
printf("Successfully enqueue'd swapA\n");
}
// If right > data AND right > left, replace data with right
else if ((temp->right->data > temp->data) && (temp->right->data > temp->left->data))
{
printf("Right child %d was greater than %d. Moving %d to back of queue...\n", temp->right->data, temp->data, temp->data);
struct node *swapB = newNode(temp->right->data);
printf("swapB->data = %d\n", swapB->data);
if (temp->left)
{
swapB->left = temp->left;
printf("temp->left copied to swapB->left. swapB->left value is %d\n", swapB->left->data);
}
if (temp->right)
{
swapB->right = temp;
printf("temp->right copied to swapB->right. swapB->right value is %d\n", swapB->right->data);
}
temp->data = temp->right->data;
printf("New temp->data: %d\n", temp->data);
enqueue(swapB, queue);
printf("Successfully enqueue'd swapB\n");
}
*/
if (temp->left)
{
printf("Enqueue'ing %d...\n", temp->left->data);
enqueue(temp->left, queue);
}
if (temp->right)
{
printf("Enqueue'ing %d...\n", temp->right->data);
enqueue(temp->right, queue);
}
//if (temp->left == NULL && temp->right == NULL)
//printf("Node with %d value has no children\n", temp->data);
}
printf("%d\n", removeFromRear(queue)->data);
}