merge: Improved the complexity of dequeue O(n) to O(1) (TheAlgorithms#1005)

* feat: improved memoize function used Map instead of object & used the JSON.stringfy method for generate a valid string as a key * docs: modified documentation * style: format with standard * docs: modified stringify doc * refactor: remove two repetition implementation * feat: added validation, test codes * chore: remove useless words * feat: added types for jest * chore: added link box * feat: added new validation test casses & methods * style: formated with standard * feat: added parse method & test cases * docs: added js docs * chore: added default import export * feat: imporved algorithm via replace method * test: added two test cases * feat: added jest type for suggestions * feat: added `reduceRight` & `trim` method * chore: added helper variable * feat: added new rotation option * Revert "chore: added helper variable" This reverts commit 489544d. * remove: yarn lock * chore: fix grammer * feat: used replace method & added test case * feat: remove revert * chore: added new line * feat: updated the Queue array to linkedlist DS * chore: fixed grammer * resolve: removed capacity related codes, & updated test cases * feat: added length dicrease code on dequeue

Author: fahimfaisaal

Data-Structures/Queue/Queue.js

@@ -1,56 +1,114 @@
 /* Queue
 * A Queue is a data structure that allows you to add an element to the end of
-* a list and remove the item at the front. A queue follows a "First In First Out"
-* system, where the first item to enter the queue is the first to be removed. This
-* implementation uses an array to store the queue.
+* a list and remove the item at the front. A queue follows a FIFO (First In First Out)
+* system, where the first item to enter the queue is the first to be removed,
+* All these operation complexities are O(1).
+* This implementation following the linked list structure.
 */
 
-// Functions: enqueue, dequeue, peek, view, length, empty
 classQueue{
-// constructor
+ #size
+
 constructor(){
-// This is the array representation of the queue
-this.queue=[]
+this.head=null
+this.tail=null
+this.#size =0
+
+returnObject.seal(this)
 }
 
-// methods
-// Add a value to the end of the queue
-enqueue(item){
-this.queue.push(item)
+getlength(){
+returnthis.#size
 }
 
-// Removes the value at the front of the queue
+/**
+ * @description - Add a value to the end of the queue
+ * @param{*} data
+ * @returns{number} - The current size of queue
+ */
+enqueue(data){
+constnode={ data,next: null}
+
+if(!this.head&&!this.tail){
+this.head=node
+this.tail=node
+}else{
+this.tail.next=node
+this.tail=node
+}
+
+return++this.#size
+}
+
+/**
+ * @description - Removes the value at the front of the queue
+ * @returns{*} - The first data of the queue
+ */
 dequeue(){
-if(this.empty()){
+if(this.isEmpty()){
 thrownewError('Queue is Empty')
 }
 
-returnthis.queue.shift()// remove the item at position 0 from the array and return it
+constfirstData=this.peekFirst()
+
+this.head=this.head.next
+
+if(!this.head){
+this.tail=null
+}
+
+this.#size--
+
+returnfirstData
 }
 
-// Return the length of the queue
-length(){
-returnthis.queue.length
+/**
+ * @description - Return the item at the front of the queue
+ * @returns{*}
+ */
+peekFirst(){
+if(this.isEmpty()){
+thrownewError('Queue is Empty')
+}
+
+returnthis.head.data
 }
 
-// Return the item at the front of the queue
-peek(){
-if(this.empty()){
+/**
+ * @description - Return the item at the tail of the queue
+ * @returns{*}
+ */
+peekLast(){
+if(this.isEmpty()){
 thrownewError('Queue is Empty')
 }
 
-returnthis.queue[0]
+returnthis.tail.data
 }
 
-// List all the items in the queue
-view(output=value=>console.log(value)){
-output(this.queue)
+/**
+ * @description - Return the array of Queue
+ * @returns{Array<*>}
+ */
+toArray(){
+constarray=[]
+letnode=this.head
+
+while(node){
+array.push(node.data)
+node=node.next
+}
+
+returnarray
 }
 
-// Return Is queue empty ?
-empty(){
-returnthis.queue.length===0
+/**
+ * @description - Return is queue empty or not
+ * @returns{boolean}
+ */
+isEmpty(){
+returnthis.length===0
 }
 }
 
-export{Queue}
+exportdefaultQueue

Data-Structures/Queue/test/Queue.test.js

@@ -1,48 +1,46 @@
-import{Queue}from'../Queue'
+importQueuefrom'../Queue'
 
-describe('Queue',()=>{
-it('Check enqueue/dequeue',()=>{
-constqueue=newQueue()
-queue.enqueue(1)
-queue.enqueue(2)
-queue.enqueue(8)
-queue.enqueue(9)
+describe('Testing the Queue DS',()=>{
+constqueue=newQueue()
 
-expect(queue.dequeue()).toBe(1)
-expect(queue.dequeue()).toBe(2)
+it('Testing enqueue method',()=>{
+expect(queue.enqueue(1)).toBe(1)
+expect(queue.enqueue(2)).toBe(2)
+expect(queue.enqueue(8)).toBe(3)
+expect(queue.enqueue(9)).toBe(4)
 })
 
-it('Check length',()=>{
-constqueue=newQueue()
-
-queue.enqueue(1)
-queue.enqueue(2)
-queue.enqueue(8)
-queue.enqueue(9)
+it('Testing length after enqueue',()=>{
+expect(queue.length).toBe(4)
+})
 
-expect(queue.length()).toBe(4)
+it('Testing peekFirst & peekLast methods',()=>{
+expect(queue.peekFirst()).toBe(1)
+expect(queue.peekLast()).toBe(9)
 })
 
-it('Check peek',()=>{
-constqueue=newQueue()
+it('Testing toArray method',()=>{
+expect(queue.toArray()).toEqual([1,2,8,9])
+})
 
-queue.enqueue(1)
-queue.enqueue(2)
-queue.enqueue(8)
-queue.enqueue(9)
+it('Testing dequeue method',()=>{
+expect(queue.dequeue()).toBe(1)
+expect(queue.dequeue()).toBe(2)
+})
 
-expect(queue.peek()).toBe(1)
+it('Testing length after dequeue',()=>{
+expect(queue.length).toBe(2)
 })
 
-it('Check empty',()=>{
+it('Testing isEmpty method',()=>{
 constqueue=newQueue()
-expect(queue.empty()).toBeTruthy()
+expect(queue.isEmpty()).toBeTruthy()
 
 queue.enqueue(1)
 queue.enqueue(2)
 queue.enqueue(8)
 queue.enqueue(9)
 
-expect(queue.empty()).toBeFalsy()
+expect(queue.isEmpty()).toBeFalsy()
 })
 })