In this article we will learn how to implementing Stack Data Structure in Javascript.
Stack is a linear data structure in which addition or removal of element follows a particular order i.e. LIFO(Last in First Out).
Create a skeleton of a stack class
Skeleton of a stack class
class Stack {
// Array is used to implement stack
constructor() {
this.items = [];
}
// Functions to be implemented:
// push(item)
// pop()
// peek()
// isEmpty()
// printStack()
}
Now we have created a skeleton for the class, and when that class is called, we can access the methods and properties of that class, like this:
const stack = new Stack();
But we didn't create any properties or methods for that class, we just did a skeleton, so if we print that class we won't find anything in it.
const stack = new Stack();
console.log(stack);
// Stack { items: [] }
Now let’s see implementation of each method:
Implementation of push
method
Now we will implement the push method, and the push method all it do is add an element to the end of the stack.
class Stack {
// Array is used to implement stack
constructor() {
this.items = [];
}
// Push method
push(element) {
// Add element to end of stack
this.items.push(element);
}
}
Now that we've done the implementation, let's do a test for the stack
// Create new stack
const stack = new Stack();
// Print before `push`
console.log(stack);
// Push new element to stack
stack.push('John');
// Print after `push`
console.log(stack);
Output
Stack { items: [] }
Stack { items: [ 'John' ] }
As you can see, the element has been added at the end of the stack.
Now let's create the function that deletes the last element of the stack.
Implementation of pop
method
pop
method removes the last element from the stack and returns it. Return "underflow"
when called on an empty stack.
Implementation
class Stack {
// Array is used to implement stack
constructor() {
this.items = [];
}
// Push method
push(element) {
this.items.push(element);
}
// Pop method
pop() {
if (this.items.length === 0) return "Underflow";
return this.items.pop();
}
}
Now that we've done the implementation, let's do a test for the stack
// Create new stack
const stack = new Stack();
// Print stack
console.log(stack);
// Push method
stack.push('John');
stack.push("Doe");
// Pop last one
console.log(stack.pop());
// Print stack
console.log(stack);
// Pop last one
console.log(stack.pop());
// Print stack
console.log(stack);
// Underflow
console.log(stack.pop());
Output
Stack { items: [] }
Doe
Stack { items: [ 'John' ] }
John
Stack { items: [] }
Underflow
Implementation of peek
method
peek
method return the topmost element without removing it from the stack.
Implementation
// return the top most element from the stack without delete
peek() {
return this.items[this.items.length - 1];
}
Now that we've done the implementation, let's do a test for the stack
// Create a stack
const stack = new Stack();
// Push elements
stack.push('John');
stack.push("Doe");
// Print Stack
console.log(stack);
// Peek method
console.log(stack.peek());
Output
Stack { items: [ 'John', 'Doe' ] }
Doe
Now we can say that we are done, but there are some helpers methods that we must implement like isEmpty
and printStack
.
Implementation of isEmpty
method
This function returns true
or false
, all it does is check whether the stack is empty or not.
Implementation
// check whether the stack is empty or not.
isEmpty() {
return this.items.length === 0;
}
let's do a test for the stack
// Create a stack
const stack = new Stack();
// Check if isEmpty or not
console.log(stack.isEmpty());
// Push elements
stack.push('John');
stack.push("Doe");
// Print stack
console.log(stack);
// Check if isEmpty or not
console.log(stack.isEmpty())
Output
true
Stack { items: [ 'John', 'Doe' ] }
false
Implementation of printStack
method
This method returns a string in which all the element of an stack is concatenated.
Implementation
// Print stack
printStack() {
var str = "";
for (let i = 0; i < this.items.length; i++) {
str += this.items[i] + " ";
}
return str;
}
Now that we've done the implementation, let's do a test for the stack
// Stack
const stack = new Stack();
// Push elements
stack.push('John');
stack.push("Doe");
// Print Stack
console.log(stack.printStack());
Output
John Doe
Full code:
class Stack {
// Array is used to implement stack
constructor() {
this.items = [];
}
// Push method
push(element) {
this.items.push(element);
}
// Pop method
pop() {
if (this.items.length === 0) return "Underflow";
return this.items.pop();
}
// return the top most element from the stack without delete
peek() {
return this.items[this.items.length - 1];
}
// check whether the stack is empty or not.
isEmpty() {
return this.items.length === 0;
}
// Print stack
printStack() {
var str = "";
for (let i = 0; i < this.items.length; i++) {
str += this.items[i] + " ";
}
return str;
}
}
Thank you for reading
Thank you for reading my blog. 🚀