Added Queue, Priority Queue and Linked List

data_structures/LinkedLists.java

@@ -0,0 +1,69 @@
+/*
+ * A linked list is similar to an array, it holds values. However, links in a linked list do not have indexes.
+ * With a linked list you do not need to predetermine it's size as it grows and shrinks as it is edited.
+ * This is an example of a singly linked list. Elements can only be added/removed at the head/front of the list.
+*/
+class LinkedList{
+	private Link head; //Head refers to the front of the list
+
+	public LinkedList(){
+		head = null;
+	}
+
+	public void insertHead(int x){	//Insert an element at the head
+		Link newLink = new Link(x); //Create a new link with a value attached to it
+		newLink.next = head; 		//Set the new link to point to the current head
+		head = newLink; 			//Now set the new link to be the head
+	}
+
+	public Link deleteHead(){ //Delete the element at the head
+		Link temp = head;
+		head = head.next; //Make the second element in the list the new head, the Java garbage collector will later remove the old head
+		return temp;
+	}
+
+	public boolean isEmpty(){ //Returns true if list is empty
+		return(head == null);
+	}
+
+	public void display(){ //Prints contents of the list
+		Link current = head;
+		while(current!=null){
+			current.displayLink();
+			current = current.next;
+		}
+		System.out.println();
+	}
+}
+
+class Link{
+	public int value;
+	public Link next; //This is what the link will point to
+
+	public Link(int valuein){
+		value = valuein;
+	}
+
+	public void displayLink(){
+		System.out.print(value+" ");
+	}
+}
+
+//Example
+public class LinkedLists{
+	public static void main(String args[]){
+		LinkedList myList = new LinkedList();
+
+		System.out.println(myList.isEmpty()); //Will print true
+
+		myList.insertHead(5);
+		myList.insertHead(7);
+		myList.insertHead(10);
+
+		myList.display(); // 10(head) --> 7 --> 5
+
+		myList.deleteHead();
+
+		myList.display(); // 7(head) --> 5
+	}
+}

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]; //Shifts every element up to make room for insertion
+				j--;
+			}
+			queueArray[j] = value; //Once the correct position is found the value is inserted
+		}
+		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
+	}
+}

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 	
+	}
+}