pqueue-heap

Author: mswilkison

Assignment5/pqueue-heap.cpp

@@ -0,0 +1,83 @@
+/*************************************************************
+ * File: pqueue-heap.cpp
+ *
+ * Implementation file for the HeapPriorityQueue
+ * class.
+ */
+ 
+#include "pqueue-heap.h"
+#include "error.h"
+
+HeapPriorityQueue::HeapPriorityQueue() {
+    capacity = INITIAL_CAPACITY;
+    count = 0;
+    array = new string[capacity];
+}
+
+HeapPriorityQueue::~HeapPriorityQueue() {
+    delete[] array;
+}
+
+int HeapPriorityQueue::size() {
+    return count;
+}
+
+bool HeapPriorityQueue::isEmpty() {
+    return count == 0;
+}
+
+void HeapPriorityQueue::enqueue(string value) {
+    if (count == capacity) expandCapacity();
+    array[count] = value;
+    count++;
+    if (count > 1) bubbleup(count);
+}
+
+string HeapPriorityQueue::peek() {
+    if (isEmpty()) error("peek: Attempting to peek into an empty pqueue");
+    return array[0];
+}
+
+string HeapPriorityQueue::dequeueMin() {
+    if (isEmpty()) error("dequeueMin: Attempting to dequeue and empty pqueue");
+    string first = array[0];
+    array[0] = array[count - 1];
+    count--;
+    if (count > 1) bubbledown(1); // bubbledown first element
+    return first;
+}
+
+void HeapPriorityQueue::expandCapacity() {
+    string *oldArray = array;
+    capacity *= 2;
+    array = new string[capacity];
+    for (int i = 0; i < count; i++) {
+        array[i] = oldArray[i];
+    }
+    delete[] oldArray;    
+}
+
+void HeapPriorityQueue::bubbleup(int index) {
+    if (array[index - 1] < array[(index / 2) - 1]) {
+        string temp = array[index - 1];
+        array[index - 1] = array[(index / 2) - 1];
+        array[(index / 2) - 1] = temp;
+        if (index / 2 - 1 >= 1) bubbleup(index / 2);
+    }
+}
+
+void HeapPriorityQueue::bubbledown(int index) {
+    if (count > (2 * index) - 1 && array[index - 1] > array[(2 * index) - 1]) {
+        string temp = array[index - 1];
+        array[index - 1] = array[(2 * index) - 1];
+        array[(2 * index) - 1] = temp;
+        bubbledown(2 * index);
+    }
+    
+    if (count > 2 * index && array[index - 1] > array[2 * index]) {
+        string temp = array[index - 1];
+        array[index - 1] = array[2 * index];
+        array[2 * index] = temp;
+        bubbledown(2 * index + 1);
+    }
+}

Assignment5/pqueue-heap.h

@@ -0,0 +1,57 @@
+/**********************************************
+ * File: pqueue-heap.h
+ *
+ * A priority queue class backed by a binary
+ * heap.
+ */
+#ifndef PQueue_Heap_Included
+#define PQueue_Heap_Included
+
+#include <string>
+using namespace std;
+
+/* A class representing a priority queue backed by an
+ * binary heap.
+ */
+class HeapPriorityQueue {
+public:
+	/* Constructs a new, empty priority queue backed by a binary heap. */
+	HeapPriorityQueue();
+	
+	/* Cleans up all memory allocated by this priority queue. */
+	~HeapPriorityQueue();
+	
+	/* Returns the number of elements in the priority queue. */
+	int size();
+	
+	/* Returns whether or not the priority queue is empty. */
+	bool isEmpty();
+	
+	/* Enqueues a new string into the priority queue. */
+	void enqueue(string value);
+	
+	/* Returns, but does not remove, the lexicographically first string in the
+	 * priority queue.
+	 */
+	string peek();
+	
+	/* Returns and removes the lexicographically first string in the
+	 * priority queue.
+	 */
+	string dequeueMin();
+
+private:
+    static const int INITIAL_CAPACITY = 10;
+    
+    // Instance variables
+    string *array;
+    int count;
+    int capacity;
+    
+    // Private method prototypes
+    void expandCapacity();
+    void bubbleup(int index);
+    void bubbledown(int index);
+};
+
+#endif