diff --git a/week-09-1/CMakeLists.txt b/week-09-1/CMakeLists.txt new file mode 100644 index 0000000..0d80f67 --- /dev/null +++ b/week-09-1/CMakeLists.txt @@ -0,0 +1,6 @@ +cmake_minimum_required(VERSION 3.16) +project(week-09-1) + +set(CMAKE_CXX_STANDARD 14) + +add_executable(week-09-1 main.cpp) diff --git a/week-09-1/main.cpp b/week-09-1/main.cpp new file mode 100644 index 0000000..2fd1a76 --- /dev/null +++ b/week-09-1/main.cpp @@ -0,0 +1,104 @@ +// Adaptation to the code found at +// Week 5: Lectures +// Demonstrates sorted linked list +#include + +using namespace std; + +///////////////////////////////////////////////////////////// +class Node { +public: + int filenumber; // the file number + Node *pNext; // ptr to next link in list +//---------------------------------------------------------- + Node(int value) : // constructor + filenumber(value), pNext(NULL) {} + +//---------------------------------------------------------- + void displayNode() // display ourselves {22} + { + cout << "{" << filenumber << "} "; + } +//---------------------------------------------------------- +}; // end class Node +///////////////////////////////////////////////////////////// +class NodeList { +private: + Node *pFirst; // ptr to first link on list +public: +//---------------------------------------------------------- + NodeList() : pFirst(NULL) // constructor + {} // no links on list yet +//---------------------------------------------------------- + ~NodeList(){ // destructor + while(!isEmpty()){ // until it's empty, + removeFirst(); // remove it + } + } +//---------------------------------------------------------- + bool isEmpty() // true if list is empty + { return pFirst == NULL; } +//---------------------------------------------------------- + Node *getFirst() // return first link + { return pFirst; } +//---------------------------------------------------------- + void insert(int value) // insert, in order + { + Node* pNewLink = new Node(value); // make new link + Node* pPrevious = NULL; // pointer to previous + Node* pCurrent = pFirst; // start at first + // Look for position prior to the end of the list + // We quicksort insert by value + while(pCurrent != NULL && value > pCurrent->filenumber) + { + pPrevious = pCurrent; // adjust previous ptr + pCurrent = pCurrent->pNext; // go to next item + } + // Insert link the link + if(pPrevious==NULL) // at beginning of list + pFirst = pNewLink; // first --> newLink + else // not at beginning + pPrevious->pNext = pNewLink; // old prev --> newLink + pNewLink->pNext = pCurrent; // newLink --> old current + } // end insert() +//---------------------------------------------------------- + void removeFirst() // delete first link + { // (assumes list not empty) + Node *pTemp = pFirst; // save first + pFirst = pFirst->pNext; // unlink it: first-->old next + delete pTemp; // delete old first + } +//---------------------------------------------------------- + void displayList() { + cout << "List (value): "; + Node *pCurrent = pFirst; // start at beginning of list + while (pCurrent != NULL) // until end of list, + { + pCurrent->displayNode(); // print data + pCurrent = pCurrent->pNext; // move to next link + } + cout << endl; + } +//---------------------------------------------------------- +}; // end class NodeList +///////////////////////////////////////////////////////////// +int main() { + NodeList theList; // make new list + cout << "Demonstrating the sorted link-list program" << endl; + theList.insert(421003); + theList.insert(100298); + theList.insert(494002); + theList.insert(93); + theList.insert(3994); + theList.insert(21093); + theList.insert(3949500); + theList.insert(29100); + theList.insert(6493939); + theList.insert(202814); + theList.insert(506984); + theList.insert(2); + theList.insert(665778); + cout << " This is all the values that are now in the linked list" << endl; + theList.displayList(); + return 0; +} \ No newline at end of file diff --git a/week-09-2/CMakeLists.txt b/week-09-2/CMakeLists.txt new file mode 100644 index 0000000..5657a3e --- /dev/null +++ b/week-09-2/CMakeLists.txt @@ -0,0 +1,6 @@ +cmake_minimum_required(VERSION 3.16) +project(week-09-2) + +set(CMAKE_CXX_STANDARD 14) + +add_executable(week-09-2 main.cpp) diff --git a/week-09-2/main.cpp b/week-09-2/main.cpp new file mode 100644 index 0000000..33f7cb7 --- /dev/null +++ b/week-09-2/main.cpp @@ -0,0 +1,124 @@ +//SDEV345-81 +//Kodi Lein +#include +using namespace std; + +/*Node Class*/ +class Node +{ +public: + int data; + Node* next; + Node* prev; +}; + +/*Swap elements*/ +void swap(int* a, int* b) +{ + int t = *a; *a = *b; *b = t; +} + +/*Find last node in list*/ +Node* lastNode(Node* root) +{ + while (root && root->next) + root = root->next; + return root; +} + +/*Define pivot point and moves smaller elements to left, larger to right*/ +Node* partition(Node* l, Node* h) +{ + //h = pivot point + int x = h->data; + + Node* i = l->prev; + + for (Node* j = l; j != h; j = j->next) + { + if (j->data <= x) + { + i = (i == NULL) ? l : i->next; + + swap(&(i->data), &(j->data)); + } + } + i = (i == NULL) ? l : i->next; + swap(&(i->data), &(h->data)); + return i; +} + +/*Quicksort function*/ +void QS(Node* l, Node* h) +{ + if (h != NULL && l != h && l != h->next) + { + Node* p = partition(l, h); + QS(l, p->prev); + QS(p->next, h); + } +} + +//Calls function quicksort +void quickSort(Node* head) +{ + // Find last node + Node* h = lastNode(head); + + // Call the recursive QuickSort + QS(head, h); +} + +void printList(Node* head) +{ + while (head) + { + cout << head->data << " "; + head = head->next; + } + cout << endl; +} + +/*Insert Node*/ +void push(Node** head_ref, int new_data) +{ + Node* new_node = new Node; + new_node->data = new_data; + + new_node->prev = NULL; + + new_node->next = (*head_ref); + + if ((*head_ref) != NULL) (*head_ref)->prev = new_node; + + (*head_ref) = new_node; +} + +/*MAIN*/ +int main() +{ + Node* a = NULL; + push(&a, 421003); + push(&a, 100298); + push(&a, 494002); + push(&a, 93); + push(&a, 3394); + push(&a, 21093); + push(&a, 3949500); + push(&a, 29100); + push(&a, 6493939); + push(&a, 202814); + push(&a, 506984); + push(&a, 2); + push(&a, 665778); + + cout << "Linked List before sorting \n"; + printList(a); + + quickSort(a); + + cout << "\nLinked List after sorting \n"; + printList(a); + + return 0; +} \ No newline at end of file diff --git a/week-09-3/CMakeLists.txt b/week-09-3/CMakeLists.txt new file mode 100644 index 0000000..e5f924b --- /dev/null +++ b/week-09-3/CMakeLists.txt @@ -0,0 +1,6 @@ +cmake_minimum_required(VERSION 3.16) +project(week-09-3) + +set(CMAKE_CXX_STANDARD 14) + +add_executable(week-09-3 main.cpp) diff --git a/week-09-3/main.cpp b/week-09-3/main.cpp new file mode 100644 index 0000000..fe376c6 --- /dev/null +++ b/week-09-3/main.cpp @@ -0,0 +1,215 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Champlain College SDEV-345-81 + * + * C++ Week 9: Quicksort (first semester) - (2020/10/30) + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * + * Write a program that will randomly populate an array of 250 integers and print them + * out in a formatted way to the console. Once printed, call a quicksort algorithm to + * sort the array and print it out again, this time in order. + * + * Include the worst case running time in your output. + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * + * Written by Llewellyn van der Merwe , October 2020 + * Copyright (C) 2020. All Rights Reserved + * License GNU/GPL Version 2 or later - http://www.gnu.org/licenses/gpl-2.0.html + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#include +#include +#include +#include + +using namespace std; +using namespace std::chrono; + +// Quick Sort Class +class QuickSort { +private: + // the comparison counter + int comparison_counter; + // local sort needed for quick sort + void sort(int *arr, int low, int high) { + // some default stuff + int i = low; + int j = high; + int pivot = *(arr + ((i + j) / 2)); + int temp; + // compare the array positions + while (position_compare(&i, &j)) { + // compare the array values + while (compare(&pivot, (arr + i))) + i++; + // compare the array values + while (compare((arr + j), &pivot)) + j--; + // compare the array positions + if (position_compare(&i, &j)) { + temp = *(arr + i); + *(arr + i) = *(arr + j); + *(arr + j) = temp; + i++; + j--; + } + } + // compare the array values + if (compare(&j, &low)) + sort(arr, low, j); + // compare the array values + if (compare(&high, &i)) + sort(arr, i, high); + } + // local compare for the positions + bool position_compare(int *a, int *b) { + comparison_counter++; // not sure if this should also be count (just comment out this line if not) + return *a <= *b; + } + // function to compare values + bool compare(int *a, int *b) { + comparison_counter++; + return *a > *b; + } +public: + // get comparison counter + int getComparisonCounter() { return comparison_counter; } + // sort function + void sort(int *arr, int size ) { + comparison_counter = 0; + sort(arr, 0, size - 1); + } +}; + +// function declarations +void printArray(int arr[], int size, string action); +void reverseArray(int arr[], int start, int end); +void printNotice(int microseconds, int comparisons, string status); +void printWorseCase(int random, int revers, int sorted); + +// main function +int main() { + // the size of our array + const int SIZE = 250; + // for random seeding + time_t aTime; + // array we would like to sort + int arr[SIZE]; + // Instantiate Quick Sort + shared_ptr quick = make_shared(); + // Seed randoms + srand( static_cast(time(&aTime)) ); + // load 250 random values (between 0 - 3000) + for(int i = 0; i < SIZE; i++) { + arr[i] = rand() % 3000; + } + // start the display + cout << endl << " | THE QUICKSORT DEMONSTRATION" << endl; + // display array before sorting + printArray(arr, SIZE, "Random"); + // now we sort the the array + cout << " | Sorting the RANDOM array with Quicksort" << endl; + // get the starting point of the sort + auto start = high_resolution_clock::now(); + // sort the array + quick->sort(arr, SIZE); + // After sort + auto stop = high_resolution_clock::now(); + // display proof that the array was sorted + printArray(arr, SIZE, "Sorted"); + // we get the duration of the sort in microseconds + auto duration = duration_cast(stop - start); + // give notice + printNotice(duration.count(), quick->getComparisonCounter(), "RANDOM"); + // reverse the array to sort the array in worse case + reverseArray(arr, 0, SIZE-1); + // display proof that the array was reversed + printArray(arr, SIZE, "Reversed"); + // now we sort the the array + cout << " | Sorting the REVERSED array with Quicksort" << endl; + // get the starting point of the sort + auto again_start = high_resolution_clock::now(); + // sort the array + quick->sort(arr, SIZE); + // After sort + auto again_stop = high_resolution_clock::now(); + // display proof that the was sorted + printArray(arr, SIZE, "Sorted"); + // we get the duration of the sort in microseconds + auto again_duration = duration_cast(again_stop - again_start); + // give notice + printNotice(again_duration.count(), quick->getComparisonCounter(), "REVERSED"); + // now we sort the the array + cout << "_|___________________________________________________" << endl; + cout << " | Sorting the SORTED array with Quicksort" << endl; + // get the starting point of the sort + auto and_again_start = high_resolution_clock::now(); + // sort the array + quick->sort(arr, SIZE); + // After sort + auto and_again_stop = high_resolution_clock::now(); + // proof that it was sorted + printArray(arr, SIZE, "Still Sorted"); + // we get the duration of the sort in microseconds + auto and_again_duration = duration_cast(again_stop - again_start); + // give notice + printNotice(and_again_duration.count(), quick->getComparisonCounter(), "SORTED"); + // print the worse case + printWorseCase(duration.count(), again_duration.count(), and_again_duration.count()); + return 0; +} + +// Function to reverse arr[] from start to end +// https://www.geeksforgeeks.org/write-a-program-to-reverse-an-array-or-string/ +void reverseArray(int arr[], int start, int end) +{ + while (start < end) + { + int temp = arr[start]; + arr[start] = arr[end]; + arr[end] = temp; + start++; + end--; + } +} + +// Utility function to print an array +// https://www.geeksforgeeks.org/write-a-program-to-reverse-an-array-or-string/ +void printArray(int arr[], int size, string action) +{ + cout << "_|___________________________________________________" << endl; + cout << " | Display " << action; + for (int i = 0; i < size; i++) { + if (i % 20 == 0) { + cout << endl; + cout << " | "; + } + cout << arr[i] << " "; + } + cout << endl << "_|___________________________________________________" << endl; +} + +// little function to print out notices +void printNotice(int microseconds, int comparisons, string status) { + // show the duration + cout << " | SORT Duration with (" << status << " ARRAY): " << microseconds << "μs" << endl; + // show the comparisons + cout << " | SORT Comparisons: " << comparisons << endl; +} + +// little function to print the worse case +void printWorseCase(int random, int revers, int sorted) { + // show the worse case + cout << "_|___________________________________________________" << endl; + cout << " | QUICKSORT WORSE CASE WAS "; + if(random > revers && random > sorted) { + cout << "RANDOM ARRAY: " << random << "μs" << endl; + } else if(revers > random && revers > sorted) { + cout << "REVERSED ARRAY: " << revers << "μs" << endl; + } else { + cout << "SORTED ARRAY: " << sorted << "μs" << endl; + } + cout << "_|___________________________________________________" << endl; +}