Mastering String Reversal with Stack: A Professional Guide in JavaScript

Reversing a string is a classic programming challenge, often used to demonstrate mastery of fundamental data structures. In this article, we’ll explore an elegant solution using a stack, a Last In, First Out (LIFO) data structure, to reverse a string in JavaScript.

Why Use a Stack?

Stacks are ideal for problems that require reversing order due to their LIFO nature. By pushing elements onto the stack and then popping them off, we can effortlessly reverse their sequence.

Implementation in JavaScript

Here’s a concise yet powerful JavaScript implementation for reversing a string using a stack:

let string = "hello";
let data = [];
// maxLimit = 100

function push(el) {
  if (data.length < 100) {
    data[data.length] = el;
  } else {
    alert("Stack is Full");
  }
}

function pop() {
  if (data.length != 0) {
    let lastel = data[data.length - 1];
    data.length--;
    return lastel;
  } else {
    alert("Stack is Already Empty");
  }
}

function revString(str) {
  let strArr = str.split("");

  // Inserting characters into the stack
  for (let i = 0; i < strArr.length; i++) {
    push(strArr[i]);
  }

  // Popping characters from the stack to build the reversed string
  let revStr = [];
  for (let i = 0; i < strArr.length; i++) {
    let lastem = pop();
    revStr[i] = lastem;
  }
  return revStr.join("");
}

console.log(revString(string)); // Output: "olleh"        

Step-by-Step Breakdown

1. Initialization

We begin with the string "hello" and an empty array data to serve as our stack. The stack’s maximum limit is implicitly set to 100 elements.

2. Push Function

The push function adds elements to the stack, ensuring it doesn’t exceed the maximum limit. If the limit is reached, an alert notifies the user.

3. Pop Function

The pop function removes and returns the last element from the stack. If the stack is empty, it alerts the user.

4. Reversal Logic

• Splitting the String: The input string is split into an array of characters.
• Stack Operations: Each character is pushed onto the stack, then popped off in reverse order to build the reversed string.
• Joining the Result: The reversed characters are joined to form the final reversed string.

Output

The output for the input string "hello" is the reversed string "olleh".