Implemented priority queue in C; removed C++ heap

include/priorityqueue.h

@@ -52,4 +52,4 @@ int insert(struct priority_queue_t *queue, struct process_t *process);
  * @param process 
  * @return int 
  */
-int remove(struct priority_queue_t *queue, struct process_t *process);
+int remove(struct priority_queue_t *queue, struct process_t *process);

src/heap.hpp

@@ -1,98 +0,0 @@
-#ifndef SCHEDULER_H
-#define SCHEDULER_H
-
-#include <stddef.h>
-
-#include "process.hpp"
-
-namespace kernelns
-{
-
-template<class T>
-class Heap
-{
-public:
-
-    Heap()
-    {
-
-    }
-
-    Heap(T** array, size_t maxSize)
-    {
-        m_array = array;
-        m_size = 0;
-        m_limit = maxSize;
-    }
-
-    T* extractMin()
-    {
-        if(m_size == 0)
-            return nullptr;
-        m_size--;
-        T* p = m_array[0];
-        m_array[0] = m_array[m_size];
-        heapify(0);
-        return p;
-    }
-
-    Status insert(T* n)
-    {
-        if(m_size == m_limit)
-            return Status::NoMemory;
-        size_t i = m_size;
-        m_size++;
-        while(i > 0 && *m_array[(i - 1) / 2] > *n)
-        {
-            m_array[i] = m_array[(i - 1) / 2];
-            i = (i - 1) / 2;
-        }
-        m_array[i] = n;
-        return Status::OK;
-    }
-
-    void remove(T* n)
-    {
-        for(size_t i = 0; i < m_size; i++)
-        {
-            if(m_array[i] == n)
-            {
-                m_size--;
-                m_array[i] = m_array[m_size];
-                heapify(i);
-                break;
-            }
-        }
-    }
-
-private:
-
-    void heapify(size_t index)
-    {
-        if(i * 2 + 1 >= m_size)
-		    return;
-        if (*m_array[i * 2 + 1] <= *m_array[i] && *m_array[i * 2 + 1] <= *m_array[i * 2 + 2])
-        {
-            T buffer = m_array[i];
-            m_array[i] = m_array[i * 2 + 1];
-            m_array[i * 2 + 1] = buffer;
-            heapify(i * 2 + 1);
-        }
-        else if (*m_array[i * 2 + 2] <= *m_array[i] && *m_array[i * 2 + 2] <= *m_array[i * 2 + 1])
-        {
-            T buffer = m_array[i];
-            m_array[i] = m_array[i * 2 + 2];
-            m_array[i * 2 + 2] = buffer;
-            heapify(i * 2 + 2);
-        }
-    }
-
-    T** m_array;
-
-    size_t m_size, m_limit;
-
-};
-
-};
-
-#endif

src/priorityqueue.c

@@ -0,0 +1,67 @@
+#include "priorityqueue.h"
+#include "types/status.h"
+
+void heapify(struct priority_queue_t *queue, size_t i)
+{
+    if(i * 2 + 1 >= queue->size)
+    {
+        return;
+    }
+    else if(queue->heap[i * 2 + 1]->priority <= queue->heap[i]->priority
+        && queue->heap[i * 2 + 1]->priority <= queue->heap[i * 2 + 2]->priority)
+    {
+        struct process_t *buffer = queue->heap[i];
+        queue->heap[i] = queue->heap[i * 2 + 1];
+        queue->heap[i * 2 + 1] = buffer;
+        heapify(queue, i * 2 + 1);
+    }
+    else if(queue->heap[i * 2 + 2]->priority <= queue->heap[i]->priority
+        && queue->heap[i * 2 + 2]->priority <= queue->heap[i * 2 + 1]->priority)
+    {
+        struct process_t *buffer = queue->heap[i];
+        queue->heap[i] = queue->heap[i * 2 + 2];
+        queue->heap[i * 2 + 2] = buffer;
+        heapify(queue, i * 2 + 2);
+    }
+}
+
+struct process_t *extract_min(struct priority_queue_t *queue)
+{
+    if(queue->size == 0)
+        return NULL;
+    queue->size--;
+    struct process_t *p = queue->heap[0];
+    queue->heap[0] = queue->heap[queue->size];
+    heapify(queue, 0);
+    return p;
+}
+
+int insert(struct priority_queue_t *queue, struct process_t *process)
+{
+    if(queue->size == queue->capacity)
+        return S_OUT_OF_MEMORY;
+    size_t i = queue->size;
+    queue->size++;
+    while(i > 0 && queue->heap[(i - 1) / 2]->priority > process->priority)
+    {
+        queue->heap[i] = queue->heap[(i - 1) / 2];
+        i = (i - 1) / 2;
+    }
+    queue->heap[i] = process;
+    return S_OK;
+}
+
+int remove(struct priority_queue_t *queue, struct process_t *process)
+{
+    for(size_t i = 0; i < queue->size; i++)
+    {
+        if(queue->heap[i] == process)
+        {
+            queue->size--;
+            queue->heap[i] = queue->heap[queue->size];
+            heapify(queue, i);
+            return S_OK;
+        }
+    }
+    return S_OUT_OF_BOUNDS;
+}