# Next greater element in array

Given an array of integers, find next greater element for current element in array i.e. for each `a[i]`, find minimum `j` so that `a[j] > a[i]` and `j>i`.

For the rightmost element, value will be -1. For any i, if there is no such j, then result for that too will be -1.
In simple terms, we need to find nearest greater number for each element in given array. For example:

## Next greater element in array: Line of thought

Brute force method would be to scan array in two loops. For each element in array, scan remaining right side elements and find out the greater number. Complexity of code is `O(n2)`. How can we do better and solve this in linear time?

What if while scanning the array, we keep track of all numbers for which greater number is yet not found. Idea is that whenever we see a number, check if there are elements which are already visited in array and yet there is no greater number assigned to them. If there are such elements, we check if current element is greater than them. If yes, then for all those numbers which are less than current element, next greater element will be current number. However, we have yet not find next greater number for current number, so put it back to list.

This list will be in decreasing order, as we will be removing all the numbers which are less than current number fro the list. They got current number as next greater number. All remaining numbers on list will be greater than current number. What will be the best data structure store this list? Stack, as we are interested in last element first.
This problem is very similar to stock span problem.

### Next greater element in array : Algorithm

1. Push first element on to stack
2. While(`!stack.empty` && `stack.peek()` < current) stack.pop()
3. Pair all popped numbers with current number
4. If `stack.top() > current` or `stack.empty()`, stack.push(current)
5. After scanning all elements in array, print all elements in stack paired with -1 as there is no greater element on right side of these elements.

### Next greater element in array : Implementation

```package com.company;

import javafx.util.Pair;

import java.util.ArrayList;
import java.util.Stack;

/**
* Created by sangar on 19.9.18.
*/
public class NextGreaterElement {
public static ArrayList<Pair<Integer, Integer>> nextGreaterElement(int[] a){

Stack<Integer> s = new Stack();
ArrayList<Pair<Integer,Integer>> nextGreater = new ArrayList<>();

for(int i=0; i<a.length; i++){
while(!s.empty() && a[i] > s.peek()) {
nextGreater.add(new Pair<>(s.pop(), a[i]));
}
s.push(a[i]);
}
while(!s.empty()) nextGreater.add(new Pair<>(s.pop(), -1));
return nextGreater;
}

public static void main(String args[]){
int a[] = {100, 60, 70, 65, 80, 85, 45, 77, 56, 98};
ArrayList<Pair<Integer, Integer>> nextGreater = nextGreaterElement(a);

System.out.println(nextGreater);

}
}
```

Let’s workout an example: A = {5,6,3,35,23,6,8}. we start with empty stack = []. For the first element, we have empty stack, add 5 to stack. Now, `stack = [5]`

For next element 6, stack is not empty and element at the top of stack is less than 6. We will pop 5 from stack and create a pair. `Output = {(5,6)}`, we will push 6 back on to stack. `stack = [6]`

Next element is 3, which is less than top of stack, do nothing, and put the element on top of stack, `stack = [6,3]`

For 35, pop out 3 and 6 from stack and create pairs and add them to list. `Output = {(5,6),(6,35), (3,35)}`, add 35 to stack, `stack = [35]`

Next element is 23, which is less than top of stack, do nothing, and put the element on top of stack, `stack = [35,23]`

Again element 6, is less than top of stack, do nothing, and put the element on top of stack, `stack = [35,23,6]`

For 8, top of stack is less than 8, so pop and create pair and add to output. `Output = {(5,6),(6,35), (3,35),(6,8)}`, add 8 to stack, `stack = [35,23,8]`

Now there are not elements left, pop everything from stack and pair them with -1. Final output should be {(5,6), (6,35), (3,35), (6,8), (8, -1), (23, -1), (35, -1)}

Complexity of algorithm to find next greater element in array will be `O(N)` with extra space complexity of `O(N)` for stack.

Please share if there is something missing or wrong. If you are interested in taking personalized coaching for your interview preparations, please reach out to [email protected]

# Constant time max operation on stack

We understood stack data structure, operations on it and some examples problems which can be solved using stack. Let’s take problem which is actually based on stack and with the help of other data structures, how can make it more efficient for certain function. Today’s problem is to implement constant time max operation on stack.

To elaborate, you have been given a stack, where elements are pushed and popped randomly. At any given point of time, you have to tell max of all the elements present in stack.
For example : we have stack, we push 5,3,1, current max in stack is 5; we push 6 next, current max is 6 now. How about we pop 6 back. Current max goes back to 5 again.

## Constant time max operation: Line of thoughts

Push and pop operation in a stack are already constant time operations. Let’s concentrate on max operation.
If always just pushed on to stack, it would have been easy to just keep track of ma of all the elements we pushed on to stack. However if we are popping out from stack, this may not be as easy. Max will change if the element just popped from stack was current max. What can we do? We keep track of previous max just before the current max. What if next operation is again pop and it pops out the new current max. Again, we have to keep track of previous to previous max.
Are you getting some hint here? We have to keep track of all the max we ever saw while operating on stack in reverse order. That means the max we saw the last, goes out first. LIFO pattern and what better data structure than stack to implement that.

Idea is to have an auxiliary stack which stores all the max seen till a given point of time. Top of this auxiliary stack would be current max. What happens when pop happens on original array? We check if popped element is equal to top element of auxiliary array, that means popped element was current max. So we pop that from auxiliary stack too.

Let’s take an example and see if it works? To start with, both stacks are empty. Now, you add 2 as first element on to stack. Since auxiliary stack is empty, we add 2 on to that stack too.

Push 3 on to stack. Push operation so check if current top of aux stack is less than new element pushed. If yes, push new element to aux stack too.

Push 5 on to stack. Again, push operation and new push element is greater than top of aux stack, we push 5 there too.

Now, push 1. Tricky case. Push 1 on to original stack, but since new element is less than current top of aux stack, nothing gets pushed on aux stack.

Pop from stack now. 1 is popped, it is not equal to current top on aux stack, nothing happens.

Pop from stack again, this time popped element is equal to current max, so we have pop from aux stack too. If we are asked max at this point of time, answer would be 3.

### Constant time max operation on stack : Implementation

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 22.9.18.
*/
public class MaxStack {
Stack<Integer> stack;
Stack<Integer> auxStack;

public MaxStack() {
stack = new Stack();
auxStack = new Stack();
}

public void push(int x) {
int max = auxStack.isEmpty() ? x : auxStack.peek();
//Push on max stack only if max value is being changed.
if (max <= x) auxStack.push(x);
stack.push(x);
}

public int pop() {
int returnValue = stack.pop();
//Pop from aux stack only if ax value is being popped out.
if(auxStack.peek() == returnValue) {
auxStack.pop();
}
return returnValue;
}

public int top() {
return stack.peek();
}

public int peekMax() {
return auxStack.peek();
}

public int popMax() {
int max = peekMax();
Stack<Integer> buffer = new Stack();
while (top() != max) buffer.push(pop());
pop();
while (!buffer.isEmpty()) push(buffer.pop());
return max;
}
}
```

Complexity of implementation of constant time max operation stack is `O(n)` in terms of space, with `O(1)` time complexity for push, pop and max operation.

Wait, interviewer is not satisfied with this only. What we solve is just reporting the max element in stack at a given point of time. What if we were asked to implement pop max element from stack? Well, first of all finding the max element works as it is. However, popping max element requires popping out all element before max, popping out max and then pushing back all other elements again. Quite a lot of work, even when max operation is O(1).

Which data structure allows us to remove an element in constant time? It’s doubly link list. Once you know which node is to be removed, all we have to do is link previous node to next node. If we implement our original stack as doubly linked list, popping max from stack is `O(1)` operation without moving any other element on stack.

However finding the node in doubly linked list itself is `O(n)` operation. Back to square one. What would be helpful is that instead of just storing the max element, we store node address of max in doubly linked list. So in our aux stack, we do not store primitive data type, but a pointer to node which is current max.

Let’s see how it works? We follow the same process of finding the max as explained in earlier solution. It starts with pushing element 2 on to stack. This creates the first node on DLL and stores the pointer on stack.

Now, we push 3 on to stack. Since this is greater than current max being pointed to by top of aux stack, we push that to DLL and store the pointer as max pointer on aux stack.

As for 3, same thing happens when 5 is pushed on to stack.

Since new element pushed is less than current max, it’s pointer is not pushed on to aux stack.

After pushing 1, we want to pop max. Step 1 would be to fetch the node pointer for current max. Go to that node in doubly linked list. Remove that node from DLL and then remove the pointer from top of stack.

Make a note that whenever, new pushed element is equal to current max, push that on aux stack too. Why?

Let’s see the implementation of this method using doubly linked list.

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 22.9.18.
*/
public class MaxStackDLL {
private DoubleLinkedList dll;
private Stack<ListNode<Integer>> auxStack;

public MaxStackDLL() {
auxStack = new Stack();
dll = new DoubleLinkedList();
}

public void push(int x) {
int max = auxStack.isEmpty() ? x : auxStack.peek().getData();
//Push on max stack only if max value is being changed.
ListNode<Integer> newNode = dll.insertAtHead(x);
if (max <= x) auxStack.push(newNode);
}

public int pop() {
ListNode<Integer> returnValue = dll.deleteAtHead();

//Pop from aux stack only if ax value is being popped out.
if(auxStack.peek() == returnValue) {
auxStack.pop();
}
return returnValue.getData();
}

public int peekMax() {
return !auxStack.isEmpty() ? auxStack.peek().getData() : -1;
}

public int popMax() {
return auxStack.isEmpty() ? -1 : dll.deleteNode(auxStack.pop()).getData();
}
}
```

Doubly linked list class is as follows

```package com.company;

/**
* Created by sangar on 22.9.18.
*/
public class DoubleLinkedList {

ListNode<Integer> head;

public DoubleLinkedList(){
head = null;
}

public boolean isEmpty(){
return this.head == null;
}

public ListNode<Integer> insertAtHead(int data){
if(this.isEmpty()) {
this.head = new ListNode<Integer>(data);
return this.head;
}
/*
We are inserting node at head. So following things happen
1. Create a new node.
2. Set next of new pointer to current head.
3. Set prev of head to new node
4. Make new node as head of linked list
*/
//First two steps are done here
ListNode<Integer> newNode = new ListNode<Integer>(data,this.head, null);
//Step 3.
this.head.setPrev(newNode);
//Step 4.
this.head = newNode;

return this.head;
}

public ListNode<Integer> deleteAtHead(){
if(this.isEmpty()) {
return null;
}
/*
We are deleting node at head. So following things happen
1. Set temporary node point to head.
2. Move head to next of node.
3. Set prev of new head to NULL.
4. Free the temp node.
*/
ListNode<Integer> tempNode = this.head;
this.head = this.head.getNext();
this.head.setPrev(null);

return tempNode;
}

public ListNode<Integer> deleteNode(ListNode<Integer> node){
if(this.isEmpty()) {
return null;
}
/*
We are deleting node in between. So following things happen
1. If node has prev, set node.prev.next = node.next.
2. If node has next, set node.next.prev = node.prev
*/
if(node.getPrev() != null) node.getPrev().setNext(node.getNext());
if(node.getNext() != null) node.getNext().setPrev(node.getPrev());

return node;
}
}
```

ListNode class is as follows

```package com.company;

/**
* Created by sangar on 22.9.18.
*/
public class ListNode<T> {
private T data;

private ListNode<T> next;
private ListNode<T> prev;

public ListNode(T data){
this.data = data;
next = null;
prev = null;
}

public ListNode(T data, ListNode<T> next, ListNode<T> prev){
this.data = data;
this.next = next;
this.prev = prev;
}

public ListNode<T> getNext(){
return this.next;
}

public ListNode<T> getPrev(){
return this.prev;
}

public void setPrev(ListNode<T> newNode){
this.prev = newNode;
}

public void setNext(ListNode<T> newNode){
this.next = newNode;
}

public T getData(){
return this.data;
}
}
```

Tester class is given below. Can you add more test cases to this?

```package test;

import com.company.MaxStackDLL;
import org.junit.jupiter.api.Test;

import static org.junit.Assert.assertEquals;

/**
* Created by sangar on 22.9.18.
*/
public class MaxStackTest {

MaxStackDLL tester = new MaxStackDLL();
@Test
public void popMaxTest() {

tester.push(2);
tester.push(3);
tester.push(5);
tester.push(1);

assertEquals(5, tester.popMax());
assertEquals(3, tester.popMax());
}
}
```

Time complexity of push, pop and popMax is `O(1)`. There is additional space requirement which is `O(n)`.

Please share if there is something wrong or missing. If you are interested in taking personalized coaching by our experienced coaches, please reach out to us at [email protected]

# Implement queue using stack

In last post, we learned about stack data structure, in this post, we will discuss another data structure called queue. However, problem at hand is to implement queue using stack. Implement following functions on queue using stack
1. push() : inserts element at the back of queue.
2. pop() : removes element from front of the queue.
3. peek() : return element at front of the queue.
4. empty() : returns true if there is no element in queue.

Keep in mind that you can only use standard stack operations : push(), pop(), peek() and empty()

Stack is data structure where the element which is entered at top is taken out from top. It’s called LIFO pattern. Oppose to that queue is a FIFO data structure, where elements are entered at the rear and taken out from front. So effectively, we have to implement a FIFO data structure using LIFO data structure.

## Implement queue using stack : Line of thoughts

To implement a FIFO using LIFO data structure, we need two stacks.

Push()
When element is inserted i.e `push()` operation, new element has to be pushed down the stack at bottom, as this should be the last element to be popped. So, to push an element in queue, we will take out all existing elements from stack s1 and put them into stack s2. Now, push the new element on to stack s1. At last, pop all elements from stack s2 back to stack s1. Below picture shows what happens when you we push 3 to queue and what happens behind the scene using stacks.

Complexity of push operation with this method is `O(n)`. If there are n elements already inserted into queue, inserting a new element will require n pops from s1, n pushes to s2, then n pops from s2 and then again pushes to s1.

Pop()
If we follow the push operation described above, pop operation would be nothing but to return top of s1, which is constant operation with complexity of `O(1)`.

Peek and empty functions also run always on stack s1. For peek, return `s1.peek()` and for empty return `s1.empty()`

### Queue with stack : Push O(n), pop O(1) implementation

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 23.9.18.
*/
public class QueueWithStack {
private Stack<Integer> s1;
private Stack<Integer> s2;

public QueueWithStack(){
s1 = new Stack<>();
s2 = new Stack<>();
}

public void push(int x){
if(s1.empty()) s1.push(x);
else{
while(!s1.empty()){
s2.push(s1.pop());
}
s2.push(x);
while(!s2.empty()){
s1.push(s2.pop());
}
}
}

public int pop(){
if(s1.empty()) return -1;
return s1.pop();
}

public boolean isEmpty(){
return s1.empty();
}

public int peek(){
return s1.peek();
}
}
```

Test class for above implementation would be:

```package test;

import com.company.QueueWithStack;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
* Created by sangar on 23.9.18.
*/
public class QueueWithStackTest {

QueueWithStack tester = new QueueWithStack();
@Test
public void queueTest() {

tester.push(2);
tester.push(3);
tester.push(5);
tester.push(1);

assertEquals(2, tester.pop());
assertEquals(3, tester.pop());
assertEquals(5, tester.peek());
assertEquals(false, tester.isEmpty());
}
}
```

Can we do better than `O(n)` while pushing element in queue?

### Queue with stack : Push O(1), pop amortized complexity O(1) implementation

Push()
What if we push on s1 as it is. What does it change? It make push operation on queue `O(1)`.

Pop()
How does it impacts pop operation? If we pop all element from s1 and push them onto s2, at the top of s2 is actually the element we need. Also, due to this pop and push operation, s2 now contains all the elements in correct pop order for queue.
So idea is to always push in s1 as it is, however when popping out, check if s2 is empty or not? If not, then pop from s2 and return, if it is empty, pop all elements from s1 and push them all on s2 and return the top.

How does it impact the performance? Well, it is true that if there is not element in s2, we have pop and push on s2, which has complexity of `O(n)`. HOwever, all subsequent pop operations are O(1), this is called amortized complexity of `O(1)`.

Empty()
Queue to be empty, there should not any element in either s1 or s2.

Peek()
If s2 is empty, then pop from s1 and push on to s2 and then return peek of s2.

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 23.9.18.
*/
public class QueueWithStackOptimized {
private Stack<Integer> s1;
private Stack<Integer> s2;
private int front;

public QueueWithStackOptimized(){
s1 = new Stack<>();
s2 = new Stack<>();
}

public void push(int x){
if(s1.empty()) front = x;
s1.push(x);
}

public int pop(){
if(!s2.empty()) return s2.pop();
if(!s1.empty()) return -1;

while(!s1.empty()){
s2.push(s1.pop());
}
return s2.pop();
}

public boolean isEmpty(){
return s1.empty() && s2.empty();
}

public int peek(){
if(!s2.empty()) return s2.peek();

return front;
}
}
```

Complexity of peek function is again amortized to `O(1)`. Can you write test cases for implemented queue?

Reference : Leetcode

Please share if there is something wrong or missing. If you want to have personal coaching from our experienced coaches, please reach out to us at [email protected]

## Stacks : Stock Span Problem

The Stock Span problem is commonly asked in Google and Amazon interviews and taught as the application of the stack data structure in universities. Let’s take a look at the problem statement:

Given a list of prices of a single stock for N number of days, find stock span for each day. Stock span is defined as a number of consecutive days prior to the current day when the price of a stock was less than or equal to the price at current day.

For example, {100,60,70,65,80,85} span will be {1,1,2,1,4,5}.

If you are preparing for an interview, you can signup for a free session to find a coach to help you with your preparation.

For the first day, span is always 1. In the example we can see that for day 2 at 60, there is no day before it where the price was less than 60. Hence span is 1 again. For day 3, the price at day 2 (60) is less than 70, hence span is 2. Similarly, for day 4 and day 5. Remember days should be consecutive, that’s why the span for day 4 is 1 – even though there was a day 2 where the price was less than 65.

Stock span problem is slightly complicated to understand but the solution is pretty easy.

Let’s look at the solution. Brute force solution would be: For each day, says current day, scan all days prior to it, and increment span till the price of the stock is higher than the current day. For the simple implementation, the time complexity is `O(n2)` where n is the number of days.

## Stock Span problem: Solution

If we observe the brute force algorithm, it is evident that we are interested in a day that has a stock price that is greater than the current day’s stock price. So, we need to check the last price which was greater than the current day’s price. Can you see a potential pattern? Which is the data structure which allows you to maintain the last price and see it first? What should be the invariant here? We should be using a stack for sure! The invariant is that the stack elements should be in the increasing order of price. The element at the top should be the maximum price seen till the current day. How can we maintain this?

Go through each day’s stock price, check if the current price on top of the stack is less than the current day’s price. If yes, pop out till price on top of the stack is greater than the current day’s price, the stock span of the current day is the difference between the day of price on top of the stack and current day.
Storing the index of the last greatest stock price (i.e. the day when the stock was of that price) would make things easier as compared to storing actual stock price on the stack. Hence, store the index `i` on the stack and `price[i]` will give us the price of the stock on the ith day.

### Algorithm

1. Initialize span of day 1 (i=0) as 1 and put on to the stack.
2. For i=1 to n, do following
3. While `price[stack.top()] < price[i]` and !stack.isEmpty(), stack.pop()
4. If `price[stack.top()] > price[i]`, span = (i – stack.top())
5. Push current day index `i` on to stack.

Let’s take an example and see if this works? Let’s say prices are given on certain days are as following: 100, 60, 70, 65, 80, 85, 200

As per the above algorithm, we will put span[0] = 1, and the stack will be [0].
On day 2, stock price is 60. Stock price on day at the top of stack is 100, which is greater than 60. So `span[1]` = 1- 0 = 1. Stack = [0,1] On day 3, stock price is 70. We will pop from the stack till `price[stack.top()]` < 70, which obviously pops out 1 as price[1] = 60. So `span[2]` = 2 – 0 = 2. Push new price on stack, stack = [0,2] On day 4, stock price is 65. `price[stack.top()]` > `price[3]`, so `span[3]` = 3-2=1. Stack = [0,2,3] On day 5, stock price is 80, now we pop out 3 and 2 from stack as price[2] and price[3] are less than 80. `span[4]` = 4-0 = 4. stack = [0,4].
On day 6, stock price is 85, now we pop out 4 from stack as price[4] is less than 85. `span[5]` = 5-0 = 5. stack = [0,5].
On day 7, the stock price is 200, now we pop out 5 and 0 from the Stack as price[5] and price[0] is less than 200. Now stack is empty, at this point, `span[6]` = 6. stack = [6].

### Stock span problem: Implementation

```
import java.util.Arrays;
import java.util.Stack;

/**
* Created by sangar on 18.9.18.
*/
public class StockSpan {
public static int[] stockSpan(int[] prices){

Stack<Integer> s = new Stack();
int[] span = new int[prices.length];

//Step 1. Initialization
span[0] = 1;
s.push(0);

for(int i=1; i<prices.length; i++){
//Find the price on stack which is greater than current day's price
while(!s.empty() && prices[i] > prices[s.peek()]){
s.pop();

if(s.empty())
span[i] = i+1;
else
span[i] =  i - s.peek();

//Push current day onto top of stack
s.push(i);
}
}
return span;
}

public static void main(String args[]){
int prices[] = {100, 60, 70, 65, 80, 85, 45, 77, 56, 98, 200};
int[] span = stockSpan(prices);

Arrays.stream(span).forEach(System.out::println);

}
}

```

If you want to understand the basic implementation of the Stack data structure, this is the C code for it.

Stack implementation

```#include<stdio.h>
#include<stdlib.h>

#define STACK_SIZE 100

typedef struct stack{
int top;
int items[STACK_SIZE];
}stack;

void push(stack *ms, int item){
if(ms->top < STACK_SIZE-1){
ms->items[++(ms->top)] = item;
}
else {
printf("Stack is full\n");
}
}

int pop (stack *ms){
if(ms->top > -1 ){
return ms->items[(ms->top)--];
}
else{
printf("Stack is empty\n");
}
}
int peek(stack ms){
if(ms.top < 0){
printf("Stack empty\n");
return 0;
}
return ms.items[ms.top];
}
int isEmpty(stack ms){
if(ms.top < 0) return 1;
else return 0;
}

void stockSpan(int prices[], int days){

stack ms;
int i;

int span[days];

if(days ==0) return;

span[0] = 1;
ms.top = -1;

push(&ms, 0);

for(i=1; i<days; i++){
while(!isEmpty(ms) && prices[i] > prices[peek(ms)])
pop(&ms);

if(isEmpty(ms)){
span[i] = i+1;
}
else{
span[i] =  i - peek(ms);
}
push(&ms, i);
}

for(i=0; i<days; i++){
printf("%d  ", span[i]);

printf("\n");
}
/* Driver program */
int main(){

//int prices[6] ={100,60,70, 65, 85, 80};
int prices[] = {100, 60, 70, 65, 80, 85, 45, 77, 56, 98, 200};

int n  = sizeof(prices)/sizeof(prices[0]);

stockSpan(prices, n);
return 0;
}
```

The optimal time complexity of the stock span algorithm is O(n) along with a space-complexity of O(n).
To understand the more advanced version of the problem, watch video by Keerti Purswani here:

Now that you have learned the concept, can you solve the similar problems on HackerEarth

Please reach out if there is anything missing or wrong. If you are interested in being mentored by our experienced software engineers, please contact us, We would be glad to help you!

# Infix to postfix conversion using stack

Let’s see one more problem which use stack in solution. Problem is to convert infix to postfix expression.
Infix expression is an expression where operator comes in between two operand. For example: `A + B` is an infix expression as operator + come in between two operands A and B. This is how we human being write and interpret expressions.
Postfix expression is where operator comes after operands like `AB+C*` is a postfix expression. This is how machines interpret and evaluate expressions.

## Infix to postfix conversion : Line of thought

First thing we need to take care of while converting infix expression to postfix is precedence order of operators. Precedence order decides which operation happens in expression before others. For example, if expression is `A + B * C`, `B * C` is evaluated first before `A+B` as * as higher precedence over +.
Another example would be `(A + B) * C`, in this case A + B is evaluated first, as () has higher precedence over any other operator.

Let’s take an example and see how to convert an infix expression to postfix.

Infix -> A + B

We start with scanning each literal from the expression.As we have to put operator at the end, we will store operator when we see it and put it after operands. In this case, first we see A, we put this literal on output. So, current output would be A.
Next we see +, since it is an operator, we store it on storage. Next literal is B, we append it to output. Current output is AB. We finished scanning string, we will put all the operators on storage. So, the output will be `AB+`.

Let’s take another example, and see if we can come up with an algorithm.

Infix -> A + B * C

We scan the string, put A on output string. We put + on storage, and then put B on output. Again, we put * on to storage, and then operand C on to output string.
Now, we reached to the end of string, so we put all the operators on storage behind output string. But question is which order operators should be appended to output. If there is no precedence conflict, we should put the last seen operator first. So output will be `ABC*+`. There is important thing to be noted here : Last in first out pattern and to achieve that, we will use stack to store operators.

## Infix to postfix conversion : Algorithm

Now, we know the data structure to use, there is one more thing to understand is how to deal with precedence order.Let’s take an example, and see how it works.

Infix -> A * B + C

Put A on to output, * on to stack, B again on to output. Everything same as above example. Next we see +, that’s where we have to worry. Operator on top of stack is * which has high precedence than +. It means A * B needs to be evaluated before C is added to the result. To achieve this, we will pop all operators from stack which have higher precedence than current operator and append it to output. After that, we will put + on to stack.Current output would be `AB*`
Append C to output, as we finished scanning string, we will pop all elements on stack and append it to output string. Hence, output would be `AB*C+`

Let’s apply this algorithm to an expression and see how it works. Expression is 4*5+6/7. Initial state of output and stack would be

Start with first digit 4, it is an operand onto output string.

Next character is *, push it on to stack.

Next is 5, not an operator, put it with 4 in output string, so current state of stack and output string will be as follows

Next we get ‘+’, this is an operator. Here is some work we need to do.
Check if there is an operator already encountered, which has higher precedence than current operator. If not, then we are fine, we will add this operator in the set of operators onto stack but not yet added to postfix expression.

If there is operator which has higher precedence, then take out one by one all such operator (in the order they were encountered), till an operator with lower precedence is seen. Add all these operators to the postfix expressions string. Put the current operator in the set.
In this case + has lower precedence than *, so we will pop * from stack and put it on output string.

Next character is 6. Add it to postfix exp, it becomes 45*6 .

Now we encounter ‘/’. Since it has higher priority than + , it gets pushed to list.

Check 7 and add it to output postfix expression, 45*67.

Now we reached at the end of the expression. Now go to stack and pop operators one by one and add them to postfix expression string.

## Infix to postfix conversion : implementation

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 23.9.18.
*/
public class InfixToPostfix {
/* This function return true or false based on whether
character is operator or not
*/
public static boolean isOperator(char op){
if(op == '+' || op == '-' || op == '*' || op == '/' || op =='%')
return true;
return false;
}

/* This function returns associated precedence to an operator */
public static int precedence(char op){
switch (op){
case '+' :
case '-' :
return 1;
case '/' :
case '*' :
return 2;
case '%' :
return 3;
default :
return 4;
}
}

/* This function tell if the op1 has lower precedence than op2 */
public static boolean isLowerPrecedence(char op1, char op2){
if(precedence (op1) < precedence(op2))
return true;
return false;
}
public static String convertInixToPostfix(String infix){
Stack<Character> stack = new Stack();
StringBuilder sb = new StringBuilder();

for(int i=0; i<infix.length(); i++){
char currentCharacter = infix.charAt(i);
//If it's an operand, put it on output string
if(!isOperator(currentCharacter)){
sb.append(currentCharacter);
}
else{
if(stack.empty()) stack.push(currentCharacter);
else{
while(!stack.empty()
&& isLowerPrecedence(currentCharacter, stack.peek())){
sb.append(stack.pop());
}
stack.push(currentCharacter);
}
}
}
while(!stack.empty()) sb.append(stack.pop());

return sb.toString();
}

public static void main(String[] args){
System.out.println(convertInixToPostfix("4*5+6/7"));
}
}
```
```#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_LENGTH_EXPRESSION 100

typedef struct stack {
char items[MAX_LENGTH_EXPRESSION];
int top;
}stack;

void push(stack *s, char element){
if(s->top == MAX_LENGTH_EXPRESSION ){
printf("\n Stack is full");
return;
}
s->items[++s->top] = element;
return;
}

char pop(stack *s){
if(s->top == -1){
printf("\n Stack empty");
}
return s->items[s->top--];
}
char peek(stack *s){
if(s->top == -1){
printf("\n Stack empty");
}
return s->items[s->top];
}

void initialize(stack *s){
s->top = -1;
}

int empty(stack *s){
if(s->top == -1) return 1;
return 0;
}
/* This function return true or false based on whether
character is operator or not */
int is_operand(char op){
if(op == '+' || op == '-' || op == '*' || op == '/' || op =='%')
return 1;
return 0;
}

/* This function returns associated precedence to an operator */
int precedence(char op){
switch (op){
case '+' :
case '-' :
return 1;
case '/' :
case '*' :
return 2;
case '%' :
return 3;
default :
return 4;
}
}
/* This function tell if the op1 has lower precedence than op2 */
int lower_precedence(char op1, char op2){
if(precedence (op1) < precedence(op2))
return 1;
return 0;
}

void printStack(stack *s){
printf("\n Stack is:");
for(int i =0; i<= s->top; i++){
printf("%c", s->items[i]);
}
}

void infix_to_postfix(char *s){
stack ms;

initialize(&ms);

char *p = (char *) malloc(strlen(s));
char *post = p;
char temp;

/* Wrong input */
if(s== NULL) return ;

if(*s == '\0') return ;

while(*s != '\0'){
/* Case 1. If '(', push on to stack */
if(*s == '('){
push(&ms, *s);
}
/* Case 2. If ')', pop all op from stack till we see '(', Discard ')' */
else if(*s == ')'){
while(!empty(&ms) && peek(&ms) != '('){
*p  = pop(&ms);
p++;
}
if(!empty(&ms))
pop(&ms);
}
/* Case 3. If it is operator, pop all op on stack which are of higher
precedence than it. Push this onto stack */
else if(is_operand(*s)){
while(!empty(&ms) && (!lower_precedence(peek(&ms), *s))){
*p  = pop(&ms);
p++;
}
push(&ms, *s);
}
/* Case 4. If it neither of above, add it to postfix expression */

else{
*p = *s;
p++;
}
s++;
}
/*Flush all ops from stack once infix is completely visited */
while(!empty(&ms)){

*p  = pop(&ms);
p++;
}
printf("\nPostfix expression is : ");
printf("%s\n" , post);

}
int main(void) {
infix_to_postfix("4+5*6/7");
return 0;
}
```

Complexity of algorithm to convert infix to postfix expression is O(n), along with O(m) space complexity, where m is number of operators in expression.

Please share if there is something wrong or missing. If you are interested in taking personal coaching from our experience coaches, please reach out to us at [email protected]

# Matching parenthesis problem

We understood the concept of stack data structure in last post. Let’s discuss matching parenthesis problemwhich applies those concept. Problem statement is :

Given a string of parenthesis ‘(‘ and ‘)’, write a function which returns true if there are matching pairs and false if there are not. A matching pair means, there should be a closing parenthesis for an opening one, in correct order.

For example : `'((()))'`, function should return `TRUE`, but `')(())'` will return `FALSE`. Special case would be when there are equal number of parenthesis, closing and opening, but they are not in perfect order, hence function should return false in that case.

## Parenthesis matching problem : Line of thoughts

For each closing parenthesis, we need a corresponding opening parenthesis. There are two possibilities : Either we find one or we do not find one. If we do not find one, we can say that string does not contain matching parenthesis.
If there is corresponding opening parenthesis, then that opening parenthesis cannot be matched with any other closing parenthesis.

Also, note that every closing parenthesis will match with the most recent opening parenthesis if there is one. That means we are looking at a order where the parenthesis which came last needs to be fetched first, typical last in first out pattern, which is best implemented by stack.

For asserting that the current closing parenthesis is in sync with what we have already seen, we just need to check if current parenthesis completes a pair with opening parenthesis we last seen. Next closing parenthesis should complete pair with the one prior to last and so on.

### Parenthesis matching problem : Algorithm

1. For each character of input string
2. If character is opening parenthesis `'('`, put it on stack.
3. If character is closing parenthesis `')'`
1. Check top of stack, if it is `'('` , pop and move to next character.
2. If it is not `'('`, return false
4. After scanning the entire string, check if stack is empty. If stack is empty, return true else return false.

### Matching parenthesis problem : Implementation

```package com.company;

import java.util.Stack;

/**
* Created by sangar on 21.9.18.
*/
public class ParenthesisMatch {

public static boolean isMatchingParenthesis(String s) {
Stack<Character> stack = new Stack<>();

if (s == null) return true;

int len = s.length();
for(int i=0; i<len; i++){
switch(s.charAt(i)){
case '(' :
stack.push(s.charAt(i));
break;
case ')':
//If stack is empty, then there is an extra closing parenthesis
if(stack.isEmpty()) return false;
stack.pop();
break;
default:
return false;
}
}
//If stack is empty that means it's a matching parenthesis
return stack.empty();
}

public static void main(String[] args) {
String s = "()))";
System.out.println(isMatchingParenthesis(s));
}
}
```

Complexity of parenthesis matching algorithm is `O(N)` time to scan N length string and `O(N)` extra space for stack.
This problem is quite simple to solve, so if you are asked this question in interview, most probably interviewer wants to understand can you think of good test cases and put your code to test against them. Below are the few test cases you can try your code on.
Test cases

```1. ((())) : True
2. ())) : False
3. )((( : False
4. ( : False
5 Empty string : True
6. NULL pointer : False
```

Can you try solving this problem now on HackerEarth

Please share if there is something wrong or missing. If you are interested to take personal coaching from our experience teachers, please reach out to us at [email protected]