Added queue and stack, some enhancements on array and llist (#7)

Author: thorstendikmann

src/chapter/02_datastructures/array/array.c

@@ -25,15 +25,15 @@ void array_init(Array *a, int capacity)
 {
     a->capacity = capacity;
     a->size = 0;
-    a->elements = (char*) malloc(capacity);
+    a->elements = (char *)malloc(capacity);
 }
 
-void array_resize(Array* a, int new_capacity)
+void array_resize(Array *a, int new_capacity)
 {
     if (new_capacity != a->capacity)
     {
         // Allocate new memory
-        char* new_elements = (char*)malloc(new_capacity);
+        char *new_elements = (char *)malloc(new_capacity);
         // Copy data from old to new memory
         memcpy(new_elements, a->elements, a->size);
         // // "Manual way":
@@ -68,9 +68,9 @@ void array_insert(Array *a, int idx, char value)
     a->size++;
 }
 
-char* array_at(const Array *a, int idx)
+char *array_at(const Array *a, int idx)
 {
-    if((idx > a->capacity) || (idx > a->size))
+    if ((idx > a->capacity) || (idx > a->size))
     {
         printf("Out of bounds.");
         return "\0";
@@ -79,17 +79,17 @@ char* array_at(const Array *a, int idx)
     return &(a->elements[idx]);
 }
 
-void array_push_back(Array* a, char value)
+void array_push_back(Array *a, char value)
 {
     array_insert(a, a->size, value);
 }
 
-char array_pop_back(Array* a)
+char array_pop_back(Array *a)
 {
     return array_remove(a, a->size - 1);
 }
 
-char array_remove(Array* a, int idx)
+char array_remove(Array *a, int idx)
 {
     // Save element to be removed
     char temp = a->elements[idx];
@@ -104,14 +104,14 @@ char array_remove(Array* a, int idx)
     // Shrink if needed
     if (a->size <= a->capacity / 4)
     {
-        int new_capacity = (a->capacity / 2) + 1 ;
+        int new_capacity = (a->capacity / 2) + 1;
         array_resize(a, new_capacity);
     }
 
     return temp;
 }
 
-int array_find(Array* a, char c)
+int array_find(Array *a, char c)
 {
     for (int i = 0; i < a->capacity; i++)
     {
@@ -129,3 +129,36 @@ void array_destroy(Array *a)
     a->size = 0;
     free(a->elements);
 }
+
+void array_print_graphviz(const Array *a)
+{
+    char separator = '|';
+
+    printf("graph array\n");
+    printf("{\n");
+
+    printf("    Array [ shape = record, label = \"{");
+    for (int i = 0; i < a->capacity; i++)
+    {
+        char sep = i == (a->capacity - 1) ? ' ' : separator;
+        if (i < a->size)
+        {
+            printf("%c %c ", a->elements[i], sep);
+        }
+        else
+        {
+            printf(" %c", sep);
+        }
+    }
+    printf("}\"] ;\n");
+
+    printf("    notes [ shape = record, color = white, label = \"{");
+    for (int i = 0; i < a->capacity; i++)
+    {
+        char sep = i == (a->capacity - 1) ? ' ' : separator;
+        printf("%d %c ", i, sep);
+    }
+    printf("}\" ];\n");
+
+    printf("}\n\n");
+}

src/chapter/02_datastructures/array/array.h

@@ -89,4 +89,10 @@ int array_find(Array *a, char c);
  */
 void array_destroy(Array *a);
 
+/**
+ * Prints content of an Array to stdout in Graphviz format.
+ * @param a the array to be printed.
+ */
+void array_print_graphviz(const Array *a);
+
 #endif // ARRAY_H_

src/chapter/02_datastructures/linkedlist/linkedlist.c

@@ -244,4 +244,55 @@ node *linkedlist_find_previous(LinkedList *l, const node *item)
         previous = previous->next;
     }
     return 0;
-}
+}
+
+void linkedlist_print_graphviz(const LinkedList *l)
+{
+    printf("digraph g {\n");
+    printf("graph [\n");
+    printf("  rankdir = \"LR\"\n");
+    printf("];\n");
+
+    printf("\"%p\" [\n", (void *)l->head);
+    printf("    label = \"<f0> %p | <f1> Head\"\n", (void *)l->head);
+    printf("    style = \"filled\"\n");
+    printf("    fillcolor = \"#9dc4c4\"\n");
+    printf("    shape = \"record\"\n");
+    printf("];\n");
+
+    // Nodes
+    {
+        node *curPtr = l->head->next;
+        while (curPtr != 0 && curPtr != l->tail)
+        {
+            printf("\"%p\" [\n", (void *)curPtr);
+            printf("    label = \"<f0> %p | <f1> %c\"\n", (void *)curPtr, *(curPtr->value));
+            printf("    shape = \"record\"");
+            printf("];\n");
+
+            curPtr = curPtr->next;
+        }
+    }
+
+    printf("\"%p\" [\n", (void *)l->tail);
+    printf("    label = \"<f0> %p | <f1> Tail\"\n", (void *)l->tail);
+    printf("    style = \"filled\"\n");
+    printf("    fillcolor = \"#9dc4c4\"\n");
+    printf("    shape = \"record\"\n");
+    printf("];\n");
+
+    // Links
+    {
+        node *curPtr = l->head;
+        printf("\"%p\" -> \"%p\"\n", (void *)curPtr, (void *)curPtr->next);
+        curPtr = curPtr->next;
+        
+        while (curPtr != 0 && curPtr != l->tail)
+        {
+            printf("\"%p\" -> \"%p\"\n", (void *)curPtr, (void *)curPtr->next);
+            curPtr = curPtr->next;
+        }
+    }
+    printf("}\n");
+    printf("\n");
+}

src/chapter/02_datastructures/linkedlist/linkedlist.h

@@ -68,6 +68,13 @@ size_t linkedlist_size(const LinkedList *l);
  */
 void linkedlist_print(const LinkedList *l);
 
+/**
+ * Prints all LinkedList elements to stdout in a Graphviz format.
+ *
+ * @param l LinkedList to be printed.
+ */
+void linkedlist_print_graphviz(const LinkedList *l);
+
 /**
  * Empty given LinkedList.
  * @param l LinkedList list to operate on.

src/chapter/02_datastructures/queue/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(queue queue.cpp)
+target_link_libraries(queue linkedlist)
+set_target_properties(queue PROPERTIES PUBLIC_HEADER "queue.h")
+install(TARGETS queue PUBLIC_HEADER DESTINATION include/queue)
+
+add_executable(queue_test queue_test.cpp)
+target_link_libraries(queue_test queue)
+install(TARGETS queue_test DESTINATION bin/c02)

src/chapter/02_datastructures/queue/queue.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+
+#include "queue.h"
+extern "C"
+{
+#include "linkedlist/linkedlist.h"
+}
+
+// avoid prefixing std::
+using namespace std;
+
+namespace fom
+{
+    namespace AuD
+    {
+        Queue::Queue()
+        {
+            this->l = new LinkedList;
+            linkedlist_init(this->l);
+        }
+
+        Queue::~Queue()
+        {
+            linkedlist_destroy(this->l);
+            delete (this->l);
+            this->l = 0;
+        }
+
+        void Queue::enqueue(const char element)
+        {
+            linkedlist_push_back(this->l, element);
+        }
+
+        char Queue::dequeue()
+        {
+            // ... pretty much the only difference to a Stack:
+            // Return the "oldest" element
+            return linkedlist_pop_front(this->l);
+        }
+
+        const std::string Queue::toString()
+        {
+            std::stringstream returnStr;
+            for (size_t i = 0; i < linkedlist_size(this->l); i++)
+            {
+                const char c = *((linkedlist_at(this->l, i))->value);
+
+                returnStr << "[" << c << "]"; // << std::endl;
+            }
+
+            return returnStr.str();
+        }
+
+        std::string Queue::toGraphviz() const
+        {
+            std::stringstream returnStr;
+
+            returnStr << ("digraph g {\n");
+            returnStr << ("graph [\n");
+            returnStr << ("  rankdir = \"LR\"\n");
+            returnStr << ("];\n");
+
+            for (size_t i = 0; i < linkedlist_size(this->l); i++)
+            {
+                node* n = linkedlist_at(this->l, i);
+                const char c = *(n->value);
+
+                returnStr << "\"" << (void *)n << "\" [\n";
+                returnStr << "    label = \"<f0> " << c << "\"\n";
+                returnStr << "    shape = \"record\"\n";
+                returnStr << ("];\n");
+            }
+
+            for (size_t i = 0; i < linkedlist_size(this->l) -1; i++)
+            {
+                node* n = linkedlist_at(this->l, i);
+                returnStr << "\"" << (void *)n << "\" -> \"" << (void *)n->next  << "\"\n";
+            }
+
+            returnStr << ("}\n") << std::endl;
+            return returnStr.str();
+        }
+    }
+}

src/chapter/02_datastructures/queue/queue.h

@@ -0,0 +1,68 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+struct LinkedList;
+
+namespace fom
+{
+    namespace AuD
+    {
+        /**
+         * Queue implementation based on LinkedList.
+         */
+        class Queue
+        {
+        public:
+            /** Default constructor. */
+            Queue();
+            /** Destructor, free's resources. */
+            ~Queue();
+
+            /** Copy constructur. Not implemented here. */
+            Queue(const Queue&) = delete;
+            /** Assignment operator. Not implemented here. */
+            Queue& operator=(const Queue& other) = delete;
+
+            /**
+             * Pushes an element to the Queue.
+             *
+             * @param element the new element.
+             */
+            void enqueue(const char element);
+
+            /**
+             * Returns the top element from the Queue
+             * (and deletes it from the Queue).
+             *
+             * @return the top element.
+             */
+            char dequeue();
+
+            /**
+             * Helper to output a Queue.
+             *
+             * @return a String representation of the contents.
+             */
+            const std::string toString();
+
+            /**
+             * Convert the Queue to a string in a Graphviz format.
+             * @return a string in Graphviz format representing the data inside.
+            */
+            std::string toGraphviz() const;
+
+        private:
+// Clang does not detect we will be utilizing l in implementation.
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#endif
+            LinkedList *l;
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+        };
+    }
+}
+
+#endif // QUEUE_H

src/chapter/02_datastructures/queue/queue_test.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <string>
+
+#include "queue.h"
+
+int main()
+{
+    fom::AuD::Queue s;
+
+    std::cout << "## --- Enqueue some values to the Queue" << std::endl;
+    int ansi_start = 97; // 65 = 'A' | 97 = 'a | 48 = '0'
+    for (int i = ansi_start; i < 10 + ansi_start; ++i)
+    {
+        s.enqueue((char) i);
+    }
+    std::cout << s.toString() << std::endl;
+
+    std::cout << "## --- Dequeue & Print" << std::endl;
+    std::cout << "Dequeue: " << s.dequeue() << std::endl;
+    std::cout << s.toString() << std::endl;
+    std::cout << "Dequeue: " << s.dequeue() << std::endl;
+    std::cout << s.toString() << std::endl;
+    std::cout << "Dequeue: " << s.dequeue() << std::endl;
+    std::cout << s.toString() << std::endl;
+    std::cout << "Dequeue: " << s.dequeue() << std::endl;
+    std::cout << s.toString() << std::endl;
+    std::cout << "Dequeue: " << s.dequeue() << std::endl;
+    std::cout << s.toString() << std::endl;
+
+    return 0;
+}

src/chapter/02_datastructures/stack/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(stack stack.cpp)
+target_link_libraries(stack linkedlist)
+set_target_properties(stack PROPERTIES PUBLIC_HEADER "stack.h")
+install(TARGETS stack PUBLIC_HEADER DESTINATION include/stack)
+
+add_executable(stack_test stack_test.cpp)
+target_link_libraries(stack_test stack)
+install(TARGETS stack_test DESTINATION bin/c02)