Dequeue data structure simplified

Hello friends, in today's article, I'd be writing about my understanding of dequeue data structure, which would be helpful to us in one way or the other.

Recently, I have been reading and practising Data structure and algorithm in javascript, and one of the data structure, I came across that got me into making more research on it is the dequeue data structure.

So now let's get to know what this structure is, Dequeue is a data structure that allows both insertion and deletion of an element from both ends of a list.

The diagram above shows us clearly what a dequeue structure looks like. Dequeue can also be seen as the combination of Queues (FIFO = first in first out) and Stack (LIFO = last in first out) operations. Stacks and Queues are one ended operations, unlike the dequeue which is a double-ended operation because of what it does.

In the Dequeue system, we have the rear (i.e the end of a list) and front (which is the beginning). Elements can either be added from the front or from the rear and also can be removed vice-versa.

Now I'd drop a code snippet to show you how the dequeue data structure can be implemented in Javascript,

function Deque() {
  this.addFront = addFront
  this.removeFront = removeFront
  this.addBack = addBack
  this.removeBack = removeBack
  this.arr = []
  this.size =size
}

 function size(){
    return this.arr.length // returns the length of the list
 }

 function addFront(el) {
   return this.arr.unshift(el) // Adds an element to the beginning of the list
 }

 function addBack(el){
   return this.arr.push(el) // Adds an element to the rear(end) of the list
 }

  function removeFront(el){
    return this.arr.shift(el) // Removes element from the beginning of the list
  }

  function removeBack(el){
    return this.arr.pop(el) // Removes element from the end of the list
  }

The above code snippet creates a dequeue constructor and also chains different methods which we'd use to execute our operations.

let test = new Deque();
test.addFront('apple');
test.addFront('melon');
test.addBack('ragna')
test.arr // ['ragna', 'apple', 'melon']
test.size() // 3
test.removeBack() // pops out 'ragna'
test.arr // ['apple', 'melon']

Now we know how this operation work using Javascript.
Let's try to implement a palindrome checker using the dequeue system

function palindrome(str){
   let myQueue = new Deque();

   for(let i = 0; i < str.length; i++){
      myQueue.addBack(str[i])
   }

   let isEqual = false;

   while(myQueue.size() > 1){

     let front = myQueue.removeFront();
     let back = myQueue.removeBack();
     if(front === back){
       isEqual = true;

     }
   }
return isEqual
 }

console.log(palindrome('racecar')) // true

And this is how we implement a palindrome checker using a dequeue data structure in javascript. I hope you were able to learn one or two from this article. Kindly leave a reply or a like if you learnt something new thanks 😉.