# Data Structures & Algorithms in JavaScript(Stack)

Hello Everyone, This is part 2 in the series of blogs about data structure and algorithms in JavaScript. Previously I have explained *Array*. In this blog, I will cover *Stack. *

## What is Stack?

Stack is a linear data structure which follows a particular order in which the operations are performed. The order may be– geeksforgeeks.orgLIFO(Last In First Out) orFILO(First In Last Out).

*Real World eg. of the stack can be a pile of books, where books are placed one above another, books can be added or remove from the top of the pile of books*

### List Of Operations Available

**Push**: Insert an element in the stack.**Pop:**Remove an element from the stack.**Peek**: Return the top element of the stack.**Size**: Return Size of the stack.**isEmpty**: Check if the stack is empty if empty return true else false.**Clear**: Reset the stack.

### Implementation of Stack in JavaScript

There are two ways in which stack can implement in javascript one way by using Array or using javascript object. As Array already has a *push method to insert an element at end of the array, a pop* method to remove an element, to get the length of the array it has a property *length* which returns the size of the array if the length is equal to zero then the array is empty. you can get the array implementation of the Stack here

### Implementation of Stack using JavaScript Objects

let’s define **ES6 class** name Stack, with two properties, * count* which will keep track of the number of elements in the stack and

*, an object which will store the elements. Items object key will be incremental count property and value as the element store in it.*

**items**```
class Stack {
constructor() {
this.count = 0;
this.items = {};
}
}
```

**Push**

To add an element to the stack we will use the count property as key for the *items* object & element as value. After pushing the element in the stack we will increment the *count* property by one. **we can only add new items to the top of the stack, meaning at the end of the stack**

```
push(element) {
this.items[this.count] = element;
this.count++;
}
```

**Pop**

While removing an element from the stack, there two cases:

- If the stack is empty, return
**undefined** - If the stack is not empty
- Store the value of the top element i.e
*(count -1)* - decrement the
*count*property by one - delete element from
*items*object and return the stored value.

- Store the value of the top element i.e

**As the stack uses the LIFO principle, the last item that we added is the one that is removed**

```
pop() {
if (this.isEmpty()) {
return undefined;
}
let result = this.items[this.count-1];
this.count --;
delete this.items[this.count];
return result;
}
```

**Peek**

If the stack is empty, return **undefined** else return **Top** element i.e *(count -1)*

```
peek() {
if (this.isEmpty()) {
return undefined;
}
return this.items[this.count-1];
}
```

**Size**

Return *count* property, which keeps track of the number of elements in the stack.

```
size() {
return this.count;
}
```

**isEmpty**

Return **boolean **, if the *count* property is zero then yes **true** else **false**.

```
isEmpty() {
return this.count == 0;
}
```

**Clear**

We can reset it to the same value as we define in the class constructor method.

```
clear() {
this.items = {};
this.count = 0;
return this.items;
}
```

Or we could also pop an element from the Stack until it’s empty.

```
while (!this.isEmpty()) {
this.pop();
}
```

you can get the full source here

### Conclusion :

A stack is a data structure that uses the LIFO (Last In First Out ) principle. We can insert or remove an element from the top of the stack only

Stacks have a variety of applications in real-world problems. They can be used for backtracking problems to remember tasks or paths visited, and to undo actions.

Methods | Complexity |
---|---|

pop | O(1) |

push | O(1) |

peek | O(1) |

So, stay tuned for the next blog, in which I will cover another DS **Queue**.