From 67d3bf5ee126b30592d556c364de1a980c9bce8f Mon Sep 17 00:00:00 2001
From: Rian Gallagher <rianogallagher@gmail.com>
Date: Mon, 21 Nov 2016 22:13:34 +0000
Subject: [PATCH] Fixing folder problems

---
 data_structures/PriorityQueues.java | 68 +++++++++++++++++++++++
 data_structures/Queues.java         | 86 +++++++++++++++++++++++++++++
 2 files changed, 154 insertions(+)
 create mode 100644 data_structures/PriorityQueues.java
 create mode 100644 data_structures/Queues.java

diff --git a/data_structures/PriorityQueues.java b/data_structures/PriorityQueues.java
new file mode 100644
index 00000000..cacec5f3
--- /dev/null
+++ b/data_structures/PriorityQueues.java
@@ -0,0 +1,68 @@
+/*
+ * A priority queue adds elements into positions based on their priority.
+ * So the most important elements are placed at the front/on the top.
+ * In this example I give numbers that are bigger, a higher priority.
+ * Queues in theory have no fixed size but when using an array implementation it does.
+ */
+class PriorityQueue{
+	private int maxSize;
+	private int[] queueArray;
+	private int nItems;
+
+	public PriorityQueue(int size){ //Constructor
+		maxSize = size;
+		queueArray = new int[size];
+		nItems = 0;
+	}
+
+	public void insert(int value){ //Inserts an element in it's appropriate place
+		if(nItems == 0){
+			queueArray[0] = value;
+		}
+		else{
+			int j = nItems;
+			while(j > 0 && queueArray[j-1] > value){
+				queueArray[j] = queueArray[j-1];
+				j--;
+			}
+			queueArray[j] = value;
+		}
+		nItems++;
+	}
+
+	public int remove(){ //Remove the element from the front of the queue
+		return queueArray[--nItems];
+	}
+
+	public int peek(){ //Checks what's at the front of the queue
+		return queueArray[nItems-1];
+	}
+
+	public boolean isEmpty(){ //Returns true is the queue is empty
+		return(nItems == 0);
+	}
+
+	public boolean isFull(){ //Returns true is the queue is full
+		return(nItems == maxSize);
+	}
+
+	public int getSize(){ //Returns the number of elements in the queue
+		return nItems;
+	}
+}
+//Example
+public class PriorityQueues{
+	public static void main(String args[]){
+		PriorityQueue myQueue = new PriorityQueue(4);
+		myQueue.insert(10);
+		myQueue.insert(2);
+		myQueue.insert(5);
+		myQueue.insert(3);
+		//[2, 3, 5, 10] Here higher numbers have higher priority, so they are on the top
+
+		for(int i = 3; i>=0; i--)
+			System.out.print(myQueue.remove() + " "); //will print the queue in reverse order [10, 5, 3, 2]
+
+		//As you can see, a Priority Queue can be used as a sorting algotithm
+	}
+}
\ No newline at end of file
diff --git a/data_structures/Queues.java b/data_structures/Queues.java
new file mode 100644
index 00000000..c7725417
--- /dev/null
+++ b/data_structures/Queues.java
@@ -0,0 +1,86 @@
+/*
+ * A queue data structure functions the same as a real world queue.
+ * The elements that are added first are the first to be removed.
+ * New elements are added to the back/rear of the queue. 
+ */
+class Queue{
+	private int maxSize;
+	private int[] queueArray;
+	private int front;
+	private int rear;
+	private int nItems;
+	
+	public Queue(int size){ //Constructor
+		maxSize = size;
+		queueArray = new int[size];
+		front = 0;
+		rear = -1;
+		nItems = 0;
+	}
+	
+	public boolean insert(int x){ //Inserts an element at the rear of the queue
+		if(isFull())
+			return false;
+		if(rear == maxSize-1) //If the back of the queue is the end of the array wrap around to the front
+			rear = -1;
+		rear++;
+		queueArray[rear] = x;
+		nItems++;
+		return true;
+	}
+	
+	public int remove(){ //Remove an element from the front of the queue
+		if(isEmpty()){
+			System.out.println("Queue is empty");
+			return -1;
+		}	
+		int temp = queueArray[front];
+		front++;
+		if(front == maxSize) //Dealing with wrap-around again
+			front = 0;
+		nItems--;
+		return temp;
+	}
+	
+	public int peekFront(){ //Checks what's at the front of the queue
+		return queueArray[front];
+	}
+	
+	public int peekRear(){ //Checks what's at the rear of the queue
+		return queueArray[rear];
+	}
+	
+	public boolean isEmpty(){ //Returns true is the queue is empty
+		return(nItems == 0);
+	}
+	
+	public boolean isFull(){ //Returns true is the queue is full
+		return(nItems == maxSize);
+	}
+	
+	public int getSize(){ //Returns the number of elements in the queue
+		return nItems;
+	}
+}
+//Example
+public class Queues{
+	public static void main(String args[]){
+		Queue myQueue = new Queue(4);
+		myQueue.insert(10);
+		myQueue.insert(2);
+		myQueue.insert(5);
+		myQueue.insert(3);
+		//[10(front), 2, 5, 3(rear)]
+		
+		System.out.println(myQueue.isFull()); //Will print true
+		
+		myQueue.remove(); //Will make 2 the new front, making 10 no longer part of the queue
+		//[10, 2(front), 5, 3(rear)]
+		
+		myQueue.insert(7); //Insert 7 at the rear which will be index 0 because of wrap around
+		// [7(rear), 2(front), 5, 3]
+		
+		System.out.println(myQueue.peekFront()); //Will print 2
+		System.out.println(myQueue.peekRear()); //Will print 7 	
+	}
+}
\ No newline at end of file