From 185124a7de57aa092bc2897aba566114e56d9ffa Mon Sep 17 00:00:00 2001 From: Rian Gallagher Date: Mon, 21 Nov 2016 21:52:33 +0000 Subject: [PATCH 1/4] Added Queues and Priority Queues --- 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 000000000..cacec5f33 --- /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 000000000..c77254179 --- /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 From ec2d4ccdc8edbe5bd7ddac75e5b47faed608ea12 Mon Sep 17 00:00:00 2001 From: Rian Gallagher Date: Mon, 21 Nov 2016 22:08:00 +0000 Subject: [PATCH 2/4] fixing problem with folder --- Data_Structures/PriorityQueues.java | 68 ----------------------- Data_Structures/Queues.java | 86 ----------------------------- 2 files changed, 154 deletions(-) delete mode 100644 Data_Structures/PriorityQueues.java delete mode 100644 Data_Structures/Queues.java diff --git a/Data_Structures/PriorityQueues.java b/Data_Structures/PriorityQueues.java deleted file mode 100644 index cacec5f33..000000000 --- a/Data_Structures/PriorityQueues.java +++ /dev/null @@ -1,68 +0,0 @@ -/* - * 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 deleted file mode 100644 index c77254179..000000000 --- a/Data_Structures/Queues.java +++ /dev/null @@ -1,86 +0,0 @@ -/* - * 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 From 67d3bf5ee126b30592d556c364de1a980c9bce8f Mon Sep 17 00:00:00 2001 From: Rian Gallagher Date: Mon, 21 Nov 2016 22:13:34 +0000 Subject: [PATCH 3/4] 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 000000000..cacec5f33 --- /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 000000000..c77254179 --- /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 From c65e562e7040c87d93c8818e5f35dddaa0662ee2 Mon Sep 17 00:00:00 2001 From: Rian Gallagher Date: Tue, 22 Nov 2016 15:55:15 +0000 Subject: [PATCH 4/4] Added Queues, Priority Queues and Linked Lists --- data_structures/LinkedLists.java | 69 +++++++++++++++++++++++++++++ data_structures/PriorityQueues.java | 4 +- 2 files changed, 71 insertions(+), 2 deletions(-) create mode 100644 data_structures/LinkedLists.java diff --git a/data_structures/LinkedLists.java b/data_structures/LinkedLists.java new file mode 100644 index 000000000..1f1d32301 --- /dev/null +++ b/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 + } +} \ No newline at end of file diff --git a/data_structures/PriorityQueues.java b/data_structures/PriorityQueues.java index cacec5f33..a0c1af1a0 100644 --- a/data_structures/PriorityQueues.java +++ b/data_structures/PriorityQueues.java @@ -22,10 +22,10 @@ class PriorityQueue{ else{ int j = nItems; while(j > 0 && queueArray[j-1] > value){ - queueArray[j] = queueArray[j-1]; + queueArray[j] = queueArray[j-1]; //Shifts every element up to make room for insertion j--; } - queueArray[j] = value; + queueArray[j] = value; //Once the correct position is found the value is inserted } nItems++; }