Categories
28°C, New York
Home Javascript How to use the Stack In Javascript

How to use the Stack In Javascript

Using Counter

This method involves using a stack data structure to keep track of parentheses and ensuring they are properly closed.

  • Begin by initializing a stack.
  • Iterate, through the given string.
  • If an open parenthesis is encountered, push it onto the stack.
  • If a closing parenthesis is encountered check if it matches the element of the stack.
  • If they match, pop the element from the stack; otherwise conclude that the parentheses are not balanced and return false.
  • After iterating through all characters in the string if the stack is empty it means all parentheses have been correctly closed so return true.

Syntax:

stackname.push(value);
stackname.pop()
Javascript 
function isValidParentheses(str) {
    const stack = [];
    const pairs = {
        "(": ")",
        "[": "]",
        "{": "}",
    };

    for (let char of str) {
        if (pairs[char]) {
            stack.push(char);
        } else if (
            char === ")" ||
            char === "]" ||
            char === "}"
        ) {
            if (
                pairs[stack.pop()] !==
                char
            ) {
                return false;
            }
        }
    }

    return stack.length === 0;
}

const inputString = "({()})";
console.log(
    `Is it a valid Paranthesis ? :
${isValidParentheses(inputString)}`
);

Output
Is it a valid Paranthesis ? :
true

JavaScript Program to Check Valid Parentheses Using String

In this article, we will learn how we can check valid parentheses of a string, and write a program to check whether the pairs and order of “{ “, ” } “, “(“, “)”, “[“, “]” in the string expression is right or not.

Example: 

Input: exp = "[()][()()]()" 
Output: True.
Explanation: all of the brackets are properly formed.
Input: exp = "[(])"
Output: False
Explanation: The first and fourth brackets are not balanced because there is a closing ']' before the final '('.

Table of Content

  • Using the Stack
  • Using Counter
  • Using Regular Expression
  • Using a Map for Character Matching
  • Using a recursive function:

Similar Reads

Using the Stack

This method involves using a stack data structure to keep track of parentheses and ensuring they are properly closed....

Using Counter

This approach relies on using a counter to keep track of the balance between closing parentheses....

Using Regular Expression

In this method we employ expressions to repeatedly remove valid pairs of parentheses until none remain....

Using a Map for Character Matching

This method uses a stack and a Map to match opening and closing brackets. As characters are processed, opening brackets are pushed onto the stack. When a closing bracket is encountered, it is checked against the stack’s top. The string is valid if the stack is empty....

Using a recursive function

This approach recursively removes pairs of matching parentheses until either all parentheses are balanced or an imbalance is detected. It continues this process until the string is empty or an imbalance is found, returning true if the parentheses are balanced and false otherwise....

Tags:
#Geeks Premier League 2023 #JavaScript-DSA #JavaScript-Program #javascript-string #Geeks Premier League #JavaScript #Web Technologies

Using Counter