Data Structure

 

Stack:

 A Stack is a Last In First Out (LIFO) data structure. It supports two basic operations called push and pop. The push operation adds an element at the top of the stack, and the pop operation removes an element from the top of the stack.

The following are some common operations implemented on the stack:

• push(): When we insert an element in a stack then the operation is known as a push. If the stack is full then the overflow condition occurs.
• pop(): When we delete an element from the stack, the operation is known as a pop. If the stack is empty means that no element exists in the stack, this state is known as an underflow state.
• isEmpty(): It determines whether the stack is empty or not.
• isFull(): It determines whether the stack is full or not.'
• peek(): It returns the element at the given position.
• count(): It returns the total number of elements available in a stack.
• change(): It changes the element at the given position.
• display(): It prints all the elements available in the stack.

Creating Stack - Performing basic operations like push/pop/peek 

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // Creating a Stack
        Stack<String> stackOfCards = new Stack<>();

        // Pushing new items to the Stack
        stackOfCards.push("Jack");
        stackOfCards.push("Queen");
        stackOfCards.push("King");
        stackOfCards.push("Ace");

        System.out.println("Stack => " + stackOfCards);
        System.out.println();

        // Popping items from the Stack
        String cardAtTop = stackOfCards.pop();  // Throws EmptyStackException if the stack is empty
        System.out.println("Stack.pop() => " + cardAtTop);
        System.out.println("Current Stack => " + stackOfCards);
        System.out.println();

        // Get the item at the top of the stack without removing it
        cardAtTop = stackOfCards.peek();
        System.out.println("Stack.peek() => " + cardAtTop);
        System.out.println("Current Stack => " + stackOfCards);

    }
}

# Output
Stack => [Jack, Queen, King, Ace]

Stack.pop() => Ace
Current Stack => [Jack, Queen, King]

Stack.peek() => King
Current Stack => [Jack, Queen, King]

Queue:

A Queue is a First In First Out (FIFO) data structure.

     

There are two fundamental operations performed on a Queue:

• Enqueue: The enqueue operation is used to insert the element at the rear end of the queue. It returns void.
• Dequeue: The dequeue operation performs the deletion from the front-end of the queue. It also returns the element which has been removed from the front-end. It returns an integer value. The dequeue operation can also be designed to void.
• Peek: This is the third operation that returns the element, which is pointed by the front pointer in the queue but does not delete it.
• Queue overflow (isfull): When the Queue is completely full, then it shows the overflow condition.
• Queue underflow (isempty): When the Queue is empty, i.e., no elements are in the Queue then it throws the underflow condition.

// Java program to demonstrate a Queue

import java.util.LinkedList;

import java.util.Queue;

public class QueueExample {

public static void main(String[] args)

{

Queue<Integer> q

= new LinkedList<>();

// Adds elements {0, 1, 2, 3, 4} to

// the queue

for (int i = 0; i < 5; i++)

q.add(i);

// Display contents of the queue.

System.out.println("Elements of queue "

+ q);

// To remove the head of queue.

int removedele = q.remove();

System.out.println("removed element-"

+ removedele);

System.out.println(q);

// To view the head of queue

int head = q.peek();

System.out.println("head of queue-"

+ head);

// Rest all methods of collection

// interface like size and contains

// can be used with this

// implementation.

int size = q.size();

System.out.println("Size of queue-"

+ size);

}

}

Output: 

Elements of queue [0, 1, 2, 3, 4]
removed element-0
[1, 2, 3, 4]
head of queue-1
Size of queue-4

Deque:

The Deque is related to the double-ended queue that supports addition or removal of elements from either end of the data structure. 
It can either be used as a queue(first-in-first-out/FIFO) or as a stack(last-in-first-out/LIFO).

// Java program to demonstrate the working
// of a Deque in Java

import java.util.*;

public class DequeExample {
	public static void main(String[] args)
	{
		Deque<String> deque
			= new LinkedList<String>();

		// We can add elements to the queue
		// in various ways

		// Add at the last
		deque.add("Element 1 (Tail)");

		// Add at the first
		deque.addFirst("Element 2 (Head)");

		// Add at the last
		deque.addLast("Element 3 (Tail)");

		// Add at the first
		deque.push("Element 4 (Head)");

		// Add at the last
		deque.offer("Element 5 (Tail)");

		// Add at the first
		deque.offerFirst("Element 6 (Head)");

		System.out.println(deque + "\n");

		// We can remove the first element
		// or the last element.
		deque.removeFirst();
		deque.removeLast();
		System.out.println("Deque after removing "
						+ "first and last: "
						+ deque);
	}
}

Output:
[Element 6 (Head), Element 4 (Head), Element 2 (Head), Element 1 (Tail), Element 3 (Tail), Element 5 (Tail)]
Deque after removing first and last: [Element 4 (Head), Element 2 (Head), Element 1 (Tail), Element 3 (Tail)]
Circular Queue:
A circular queue is similar to a linear queue as it is also based on the FIFO (First In First Out) principle except that the last position is connected to the first position in a circular queue that forms a circle.