stack and queue array implementation, java.

•
• KAMRAN KHAN.
• FA14-BSE-099.
• Algorithm & Data Structure.
• Stack & Queue Array implementation.

• Stack
• A stack is a data Structure in which insertion and deletion take
place at the same end.
Stacks are known as LIFO (Last In, First Out) lists.
–The last element inserted will be the first to be retrieved.
–We can only add/remove/examine
the last element added (the "top").

STACK OPERATIONS:
● Push:
To insert an item from Top of stack is called push
operation.
● POP:
To put-off, get or remove some item from top of the
stack is the pop operation.
● IsEmpty:
Stack considered empty when there is no item on top.
IsEmpty operation return true when there is no item in stack else
false.
● IsFull:
Stack considered full if no other element can be inserted
on top of the stack.

Example of Push and Pop
• Push
– Add an element to the top of the stack.
• Pop
– Remove the element at the top of the stack.
top
IsEmpty stack
A
top
push an element
top
push another
A
B
top
pop
A

• Example of Push and Pop
• The Push Operation
• Suppose we have an empty integer stack that is capable of
holding a maximum of three values. With that stack we
execute the following push operations.
push(5);
push(10);
push(15);

• The state of the stack after each of the push operations:

• The Pop Operation
• Now, suppose we execute three consecutive pop
operations on the same stack:

• This is a sample program to demonstrate push and pop functionality in Stack in
Java:
• public class StackDemo {
• private int size = 3;
• int arr[] = new int[size];
• int front = -1; // variable declaration and initialize with -1
• public void push(int pushedElement) { // push method
• if (front < size - 1) { // when front of stack is less size-1
• front++; // increment the top
• arr[front] = pushedElement; // push value at array of front where front is
index
• System.out.println("Element " + pushedElement
• + " is pushed to Stack !");
• printElements(); // calling statement of print element method
• } else {
• System.out.println("Stack Overflow !"); // print when stack is full
• }
• }

• public void pop() { // pop method
• if (front >= 0) { // if condition true when front is greater than 0
• front--; // decrement the front
• System.out.println("Pop operation done !");
• } else {
• System.out.println("Stack Underflow !");
• }
• }
•
• public void printElements() { // display function heading
• if (front >= 0) {
• System.out.println("Elements in stack :");
• for (int i = 0; i <= front; i++) { // loop start from 0 index to the front of the
stack
• System.out.println(arr[i]); // printing statement
• }
• }
• }

• public static void main(String[] args) {
• StackDemo stackDemo = new StackDemo();
•
•
• stackDemo.push(23); // calling statement of push method with parameter
(passing value)
• stackDemo.push(2);
• stackDemo.pop(); // calling statement of pop method
• stackDemo.pop();
• }
•
• }

• Output
• If everything goes right you will see following output on console
demonstrating all possible cases in Stack Implementation.

• Queue
A queue is a Data structure, in which insertion is done at one
end, while deletion is performed at the other end.
---Accessing the elements of queues follows a First In, First Out
(FIFO) order.
--Like customers standing in a line in a store, the first
customer in is the first customer served.
--We can only add to the end of the
queue, and can only examine/remove
the front of the queue.

Enqueue and Dequeue
• Queue operations: Enqueue and Dequeue
• Like lines in a store, a queue has a front and a rear.
• Enqueue – insert an element at the rear of the queue
• Dequeue – remove an element from the front of the queue
Insert
(Enqueue)
Remove
(Dequeue) rearfront

• Example of Enqueue and Dequeue:
• Suppose we have an empty static integer queue that is
capable of holding a maximum of three values. With that
queue we execute the following enqueue operations.
Enqueue(3);
Enqueue(6);
Enqueue(9);

• The state of the queue after each of the enqueue
operations.

• Now the state of the queue after each of three consecutive
dequeue operations

Queue Implementation of Array
• There algorithms to implement Enqueue and Dequeue
– When enqueuing, the front index is always fixed and
the rear index moves forward in the array.
front
rear
Enqueue(3)
3
front
rear
Enqueue(6)
3 6
front
rear
Enqueue(9)
3 6 9

Queue Implementation of Array
– When dequeuing, the front index is fixed, and the
element at the front the queue is removed. Move all
the elements after it by one position.
Dequeue()
front
rear
6 9
Dequeue() Dequeue()
front
rear
9
rear = -1
front

• This is a sample program to demonstrate push and pop functionality in
Queue in Java.
• public class QueueDemo {
• private int size = 3; // instance variable and size of of array
• int arr[] = new int[size]; // declaration of array and assigning size to array
•
• int front = -1; // front of queue
• int rear = 0; // rear of queue
•
• public void push(int pushedElement) { // insertion method declaration
• if (front < size - 1) { // front is less then size-1
• front++; //increment the front
• arr[front] = pushedElement; // set element at array at front
• System.out.println("Element " + pushedElement
• + " is pushed to Queue !");
• display(); // display method calling statement
• } else {
• System.out.println("Overflow !");
• }
• }

• public void pop() { // deletion method declaration
• if (front >= rear) { // true till front is greater or equal to rear
• rear++;
• System.out.println("Pop operation done !");
• display(); // display method calling statement
• } else {
• System.out.println("Underflow !");
• }
• }
•
• public void display() { // display method declaration
• if (front >= rear) {
• System.out.println("Elements in Queue : ");
• for (int i = rear; i <= front; i++) { // start from rear to front
• System.out.println(arr[i]);
• }
• }
• }
•

• public static void main(String[] args) {
• QueueDemo queueDemo = new QueueDemo();
• queueDemo.pop();
• queueDemo.push(23); // calling statement of insertion
method
• queueDemo.push(2);
• queueDemo.pop(); // calling statement of deletion method
• }
•
• }

• Output
• If everything goes right you will see following output on
console demonstrating all possible cases in Queue
Implementation

stack and queue array implementation, java.

Recommended

More Related Content

What's hot (20)

Similar to stack and queue array implementation, java. (20)

Recently uploaded (20)

stack and queue array implementation, java.