Using STL stack class, implement in C++ a function that checks for balanced braces { },...

Using STL stack class, implement in C++ a function that checks for balanced braces { }, in a given string / arithmetic expressions.

Solutions

Expert Solution

Program Code Screenshot

Program Sample Console Input/Output Screenshot

Program Code to Copy

#include <bits/stdc++.h>
using namespace std;
int main()
{
        // declare variable to store expression
        string exp;

        // prompt user for input
        cout << "Enter an expression containg curly braces {}:  ";

        //read expression from user consisting of {} braces
        cin >> exp;

        // declare stl stack
        stack<char> stck;

        // variable to keep track if expression is balanced or not
        bool balanced = true;

        // evaluate expression
        int pos = 0;
        while (pos < exp.size())
        {
                // if opening bracket, then push in stack
                if (exp[pos] == '{')
                {
                        stck.push(exp[pos]);
                }
                else if (exp[pos] == '}')
                {
                        // if closing bracket then stack top must be opening bracket
                        // if yes pop it, otherwise break with failure
                        if (!stck.empty() && stck.top() == '{')
                        {
                                stck.pop();
                        }
                        else
                        {
                                break;
                                balanced = false;
                        }
                }
                pos++;
        }
        // show output
        cout << "Given expression " << exp << " is" << (balanced && stck.empty() ? " balanced" : " not balanced") << endl;
}

venereology answered 1 year ago

Next > < Previous

Related Solutions

Using STL stack class, implement in C++ the following pseudocodefunctioncheckBraces(aString: string) that checks for...

Using STL stack class, implement in C++ the following pseudocode functioncheckBraces(aString: string) that checks for balanced braces { } in a given string /arithmetic expressions. Write a main() program to test the function.// Checks the string aString to verify that braces match.// Returns true if aString contains matching braces, false otherwise.checkBraces(aString: string): boolean{aStack = a new empty stackbalancedSoFar = truei =0// Tracks character position in stringwhile (balancedSoFar and i < length of aString) {ch = character at position i in...

Using STL stack class, implement in C++ a function that converts an infix expression to postfix...

Using STL stack class, implement in C++ a function that converts an infix expression to postfix expression,

0. Introduction. In this assignment you will implement a stack as a Java class, using a...

0. Introduction. In this assignment you will implement a stack as a Java class, using a linked list of nodes. Unlike the stack discussed in the lectures, however, your stack will be designed to efficiently handle repeated pushes of the same element. This shows that there are often many different ways to design the same data structure, and that a data structure should be designed for an anticipated pattern of use. 1. Theory. The most obvious way to represent a...

Description( IN C++)!! The purpose of this challenge is to implement a stack using a Linked...

Description( IN C++)!! The purpose of this challenge is to implement a stack using a Linked List as a backing data structure Requirements Write the following structs struct Location { string name; string address; }; struct VisitNode { Location loc; VisitNode * next; }; Create a class called Stack. In this class, create a private variable VisitNode * head. This will keep track of the location of the head node. Add the following private function. This function will be used...

Implement our own stack class patterned after Java's Stack class. Start with a generic class that...

Implement our own stack class patterned after Java's Stack class. Start with a generic class that uses an ArrayList for storage of the elements: public class StackBox<E> { ArrayList<E> stack = new ArrayList<E>(); } Implement the following methods in StackBox: boolean empty() Tests if this stack is empty. E push(E item) Pushes an item onto the top of this stack. Returns item pushed. E pop() Removes the object at the top of this stack and returns that object as the...

StackBox Implement our own stack class patterned after Java's Stack class. Start with a generic class...

StackBox Implement our own stack class patterned after Java's Stack class. Start with a generic class that uses an ArrayList for storage of the elements: public class StackBox<E> { ArrayList<E> stack = new ArrayList<E>(); } Implement the following methods in StackBox: boolean empty() Tests if this stack is empty. E push(E item) Pushes an item onto the top of this stack. Returns item pushed. E pop() Removes the object at the top of this stack and returns that object as...

Implement a generic MyStack class using templates. A stack allows elements to be added and removed...

Implement a generic MyStack class using templates. A stack allows elements to be added and removed in a last-in, first-out (LIFO) manner. Stacks have an operation called push to place elements at the top of the stack, and another operation called pop to remove and return the element at the top of the stack. The only element on the stack that may be referenced is the one on the top. This means that if two elements are pushed onto the...

Implement the stack class (called Stack2) using queue, meaning that the only operations that can be...

Implement the stack class (called Stack2) using queue, meaning that the only operations that can be used are the ones defined in the Queue class. class Queue: def __init__(self): self.items = [] def isEmpty(self): return self.items == [] def enqueue(self, item): self.items.insert(0, item) def dequeue(self): return self.items.pop() def size(self): return len(self.items) The codes to fill: """ 1. Stack2 class Implement stack data structure using queue """ class Stack2: def __init__(self): # Write your definition for __init__ here def isEmpty(self): #...

1. Implement the stack abstract data type. Write it as a separate class called Stack. For...

1. Implement the stack abstract data type. Write it as a separate class called Stack. For simplicity the data type to be stored in the stack is String but you can also use generic type. 2. Test your class implementation by calling push() and pop(). If the stack is empty (size equals zero) pop() should return null and print that “stack is empty”. If stack is full (size equals max) push() returns false and prints that “stack is full”. This...

All code should be in Python 3. Implement the Stack Class, using the push, pop, str,...

All code should be in Python 3. Implement the Stack Class, using the push, pop, str, init methods, and the insurance variable 'list'.

Subjects