DSA Linear, Circular, Priority

//Linear Queue using linked list with INSERT,DELETE and DISPLAY operations
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}

class Queue {
constructor() {
this.front = null;
this.rear = null;
}

isEmpty() {
return this.front === null;
}

enqueue(data) {
let newNode = new Node(data);
if (this.rear === null) {
this.front = this.rear = newNode;
return;
}
this.rear.next = newNode;
this.rear = newNode;
}

dequeue() {
if (this.isEmpty()) {
return null;
}
let temp = this.front;
this.front = temp.next;
if (this.front === null) {
this.rear = null;
}
return temp.data;
}

display() {
if (this.isEmpty()) {
console.log("Queue is empty");
return;
}
let temp = this.front;
while (temp) {
console.log(temp.data);
temp = temp.next;
}
}
}

let q = new Queue();
q.enqueue(1);
q.enqueue(2);
q.enqueue(3);
q.enqueue(4);
console.log("Deleted element is:", q.dequeue());
console.log("Deleted element is:", q.dequeue());
q.display();

//Circular Queue using linked list with INSERT, DELETE and DISPLAY operations
class Node {
constructor(data) {
this.data = data;
this.next = null;
}
}

class CircularQueue {
constructor() {
this.head = null;
this.tail = null;
}

isEmpty() {
return this.head === null;
}

insert(data) {
const newNode = new Node(data);
if (this.isEmpty()) {
this.head = newNode;
this.tail = newNode;
newNode.next = this.head;
} else {
this.tail.next = newNode;
this.tail = newNode;
newNode.next = this.head;
}
}

delete() {
if (this.isEmpty()) {
return null;
} else if (this.head === this.tail) {
const deletedData = this.head.data;
this.head = null;
this.tail = null;
return deletedData;
} else {
const deletedData = this.head.data;
this.head = this.head.next;
this.tail.next = this.head;
return deletedData;
}
}

display() {
if (this.isEmpty()) {
return null;
} else {
let currentNode = this.head;
let result = ${currentNode.data};
currentNode = currentNode.next;
while (currentNode !== this.head) {
result += ${currentNode.data};
currentNode = currentNode.next;
}
return result;
}
}
}
const queue = new CircularQueue();
queue.insert(1);
queue.insert(2);
queue.insert(3);
console.log(queue.display()); // 1 2 3
queue.delete();
console.log(queue.display()); // 2 3

//Priority Queue using linked list with INSERT, DELETE and DISPLAY

class PQueue
{
constructor ()
{
this.front = null
this.rear = null
}

insert(ele,pri)
{
var node = new newNode(ele,pri)
if(this.front == null)
{
this.front = node
this.rear = node
}
else
{
var temp = this.front
var prev=null
while((temp != null) && (temp.pri <= pri))
{
prev=temp
temp=temp.next
}
node.next = temp
if(prev!=null)
prev.next = node
else
this.front=node
if(node.next==null)
this.rear=node

  }

}

del()
{
if(this.front==null)
console.log("Queue Empty")
else
{
var temp=this.front
console.log("Deleted element is: " + temp.data)
this.front=this.front.next
temp=null
}
if(this.front==null)
console.log("Now Queue Empty")

}

display()
{

  var temp=this.front
  while(temp!=null)
  {
    console.log(temp.data)
    temp=temp.next
  }

}

}

class newNode
{
constructor (data, pri, next)
{
this.data = data
this.pri = pri
this.next = null
}

}
const front = new PQueue()
console.log("Inserting into queue..")
front.insert(10,3)
front.insert(20,8)
front.insert(30,5)
front.insert(40,1)
front.insert(50,15)
console.log("After INSERT:")
front.display()
front.del()
console.log("After DELETE:")
front.display()