DEV Community: Deepak Maurya

Do you know what is queue data-structure ?

Deepak Maurya — Sat, 27 Feb 2021 16:58:00 +0000

What is Queue?

Queue is a one of the very important data structure as it is used in various applications.

If you are from computer science background you must have heard about this data structure. So Queue is a data structure which stores element in FIFO (First In First Out) fashion.

So the element which is added first that will be removed first.
One of the best application of queue is to store a callback function or any task which can be executed after some time.

The best example is message queue, suppose there's a application which takes your details like name and mobile number and registers you to the application and after that it send some message on the given mobile number.

So assume there are multiple users using the application and registering on the application so it will become hard to process all the data and send message to each person at the same time.

So to do that the application's architecture is designed in such a way that is takes each persons data and put a message in message queue which will be processed later.

So from above example you got the idea of what queue can do, there are plenty of applications out there you can search about it you will get more idea of that.

Now let's see how we can implement queue data structure in Java. I am using Java as a programming language but you can choose any programming language of your choice.

We will see Enqueue (adding element to queue) and Dequeue (deleting elements from queue) operations.

We will use array to implement it and use two pointers

To know at what position element is added (front pointer)
Which element to delete (rear pointer).

As we know queue follows FIFO fashion so the front pointer will be used to know the position of the last element added in queue and rear pointer will point to the last deleted element.

So initially front and rear will be -1 as they are not pointing to any element.

We will create a class QueueExample and initialize are queue, front and rear pointer and a capacity variable to know the size of queue.

public class QueueExample {
    private int[] queue;
    private int front;
    private int rear;
    private int capacity;

    public QueueExample(int size) {
        queue = new int[size];
        front = -1;
        rear = -1;
        capacity = size;
    }
}

Enqueue Operation

In this we will write a function to added element in queue and increment the front pointer so that we will know the last added element. Before adding we will check if queue has a space left for the new element.


public void enqueue(int value) {
    // check if queue has empty space
    if(isEmpty()) {
        queue[++front] = value;
    } else {
        System.out.print("Queue is full.");
    }
}

public boolean isEmpty() {
    return front < capacity;
}

Dequeue Operation

In this we will write a function which helps us deleting element from the queue. As we will delete the element we will increment out rear pointer so that we will know logically the last deleted value. Here we will not delete the elements physically, It will remain in the array and will increment the rear pointer and that will be treated as deleted logically.
Before deleting we will check if queue contains any values.


public void dequeue() {
    // check if queue has any value
    if(hasItem()) {
        int deletedValue = queue[++rear];
        System.out.println("deleted "+deletedValue);
    } else {
         System.out.println("Queue is Empty");
    }
}

public boolean hasItem() {
    return rear < front;
}

Display function

To display values from our queue.

public void display() {
    // will display values from rear to front as rear < front
    if(hasItem()) {
        for(int i = rear+1; i <= front; i++) {
            System.out.println(queue[i]+" ");
        }
    } else {
        System.out.println("Queue is Empty.");
    }
}

Driver function

  public static void main(String[] args) {
        System.out.println("This is a example of Queue.");

        QueueExample q1 = new QueueExample(5);
        // adding values
        q1.enqueue(10);
        q1.enqueue(20);
        q1.enqueue(30);
        // delete first added value i.e 10
        q1.dequeue();
        // display the result
        q1.display();
    }

Stack Data Structure

Deepak Maurya — Sun, 21 Feb 2021 15:57:59 +0000

In day-today life we have encounter this stack data structure for example stack of books or stack of boxes etc...

So, the stack data structure is structured such a way that the elements in this appears one above the other and that's why the name stack.

It follows LIFO pattern which means Last In First Out. So the element which is added at the last, at the removal time it's removed first and so on.

We can visualize how stack data structure looks like from below image:-

Before implementing let's understand few terminologies of stack data structure:-

Push() :- Push means pushing element in a stack.

Pop() :- Pop means removing element from stack.

Top :- Top points to the top-most element in the stack and as we push or pop elements from stack we increment or decrement top pointer.

Peak() :- Peak means the first value which is top value of the stack.

Let's see how we can implement stack using array in java, but you can use any programming language of your choice:-

First we will create a class and create three properties, check code for information about these properties.

class StackExample {
    private int[] arr; // used to store our stack elements
    private int top; // used to know which element is at the top
    private int capacity; // total size of stack

    public StackExample(int size) {
        arr = new int[size];
        top = -1; // will initialize with -1 as initially it is not pointing to any element
        capacity = size;
    }
}

So this will look something like the below image:-

So initially top is not pointing to any element and as we push elements into the stack we will increment the top and it will point to the top most or last pushed element.

Code for push operation :-

So, here we check if the stack is full or not, as we are using array to implement stack so it can overflow and to keep in mind that we have check for the full condition.

public void push(int value) {
        if(isFull()) {
            System.out.println("Stack is full");
        } else {
            arr[++top] = value;
        }
 }


 public boolean isFull() {
        return top == capacity - 1;
    }

After adding few values into the stack it will look like below image:-

Here the top is pointing to value 50.

Let's see code for pop operation :-

As we have checked overflow condition in push operation similarly we will check underflow operation in pop() method. So that we will not try to access empty stack.

public void pop() {
        if(isEmpty()) {
            System.out.println("Stack is empty");
        } else {
            System.out.println("Removing value: "+arr[top--]);
        }
    }

public boolean isEmpty() {
        return top == -1;
    }

Suppose we call pop method it will remove 50 from the stack and the top will be decremented and it will now point to 40.

Peak and display method code :-

public void peakValue() {
        System.out.println("Peak value is: "+arr[top]);
    }

    public void display() {
        if(isEmpty()) {
            System.out.println("Stack is empty");
        } else {
            System.out.println("Stack values are: ");
            for(int i=top; i >= 0; i--) {
                System.out.println(arr[i]);
            }
        }
    }

And here our driver method, most important code else nothing will work!

public static void main(String[] args) {
        StackExample s1 = new StackExample(5);
        s1.push(10);
        s1.push(20);
        s1.push(30);
        s1.push(40);
        s1.pop();
        s1.display();
        s1.peakValue();
    }

See how easy is to implement stack using array.
There are few advantages and disadvantages of implementing stack using array but we will not cover that in this post.

I made a clone of xiaomi phones calculator

Deepak Maurya — Mon, 17 Aug 2020 16:15:46 +0000

Hello!

I am learning ReactJs and to practice I made a clone of xiaomi phones calculator.

This application has almost all the features of xiaomi phone calculator, it includes basic arithmetic operations and it stores history of the basic operations in local storage of device and it has two more section named as Life section and Finance section.

Life section

It includes operation's like calculate Age, Discount, Length, Percentage, Time, Number System etc.

Finance section

It includes operation's like calculation of Currency conversion which supports 30 different currencies and the currency rate is fetched from API. Along with that it also contains Bill split and GST calculation feature.

This application is created using creact-react-app so it gives all the features of PWA and that can be enabled by just changing one line of code in index.js file. so this is a PWA application.

Demo

Demo of the application is available here

Code Repository

Please have a look and let me know your thoughts about it and any feedback would be appreciated.