mirror of
https://github.com/TheAlgorithms/Java.git
synced 2025-07-05 00:14:33 +08:00
Merge pull request #4 from RianGallagher/master
Added Queue, Priority Queue and Linked List
This commit is contained in:
Chetan Kaushik
69
data_structures/LinkedLists.java
Normal file
69
data_structures/LinkedLists.java
Normal file
@ -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
|
||||
}
|
||||
}
|
||||
68
data_structures/PriorityQueues.java
Normal file
68
data_structures/PriorityQueues.java
Normal file
@ -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
|
||||
}
|
||||
}
|
||||
86
data_structures/Queues.java
Normal file
86
data_structures/Queues.java
Normal file
@ -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
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user