Homework Solution: (C++ Data Structure) Having problems with ths code, I'm supposed to write a pseudocode fu…

    (C++ Data Structure) Having problems with ths code, I'm supposed to write a pseudocode function that uses LinkedStack to determine whether a string is in the language L, where a. L = {s : s contains equal numbers of A’s and B’s} b. L = {s : s is of the form An Bn for some n 0} and creat a main. LinkedStack: template<class ItemType> class StackInterface { public: /** Sees whether this stack is empty. @return True if the stack is empty, or false if not. */ virtual bool isEmpty() const = 0;   /** Adds a new entry to the top of this stack. @post If the operation was successful, newEntry is at the top of the stack. @param newEntry The object to be added as a new entry. @return True if the addition is successful or false if not. */ virtual bool push(const ItemType& newEntry) = 0;   /** Removes the top of this stack. @post If the operation was successful, the top of the stack has been removed. @return True if the removal is successful or false if not. */ virtual bool pop() = 0;   /** Returns the top of this stack. @pre The stack is not empty. @post The top of the stack has been returned, and the stack is unchanged. @return The top of the stack. */ virtual ItemType peek() const = 0; }; // end StackInterface //#endif ////////////////////////////////////////////////////////////// template<class ItemType> class Node { private: ItemType item; // A data item Node<ItemType>* next; // Pointer to next node   public: Node(); Node(const ItemType& anItem); Node(const ItemType& anItem, Node<ItemType>* nextNodePtr); void setItem(const ItemType& anItem); void setNext(Node<ItemType>* nextNodePtr); ItemType getItem() const ; Node<ItemType>* getNext() const ; }; // end Node //#include "Node.cpp" //#endif // Created by Frank M. Carrano and Tim Henry. // Copyright (c) 2013 __Pearson Education__. All rights reserved. /** @file Node.cpp Listing 4-2 */ //#include "Node.h" #include <cstddef> template<class ItemType> Node<ItemType>::Node() : next(nullptr) { } // end default constructor template<class ItemType> Node<ItemType>::Node(const ItemType& anItem) : item(anItem), next(nullptr) { } // end constructor template<class ItemType> Node<ItemType>::Node(const ItemType& anItem, Node<ItemType>* nextNodePtr) : item(anItem), next(nextNodePtr) { } // end constructor template<class ItemType> void Node<ItemType>::setItem(const ItemType& anItem) { item = anItem; } // end setItem template<class ItemType> void Node<ItemType>::setNext(Node<ItemType>* nextNodePtr) { next = nextNodePtr; } // end setNext template<class ItemType> ItemType Node<ItemType>::getItem() const { return item; } // end getItem template<class ItemType> Node<ItemType>* Node<ItemType>::getNext() const { return next; } // end getNext ////////////////////////////////////////////////////////////// //#ifndef _LINKED_STACK //#define _LINKED_STACK //#include "StackInterface.h" //#include "Node.h" template<class ItemType> class LinkedStack : public StackInterface<ItemType> { private: Node<ItemType>* topPtr; // Pointer to first node in the chain; // this node contains the stack's top   public: // Constructors and destructor: LinkedStack(); // Default constructor LinkedStack(const LinkedStack<ItemType>& aStack);// Copy constructor virtual ~LinkedStack(); // Destructor   // Stack operations: bool isEmpty() const; bool push(const ItemType& newItem); bool pop(); ItemType peek() const; }; // end LinkedStack //#include "LinkedStack.cpp" //#endif /////////////////////////////////////////////////////////////// //#include <cassert> // For assert //#include "LinkedStack.h" // Header file template<class ItemType> LinkedStack<ItemType>::LinkedStack() : topPtr(nullptr) { } // end default constructor template<class ItemType> LinkedStack<ItemType>::LinkedStack(const LinkedStack<ItemType>& aStack) { // Point to nodes in original chain Node<ItemType>* origChainPtr = aStack.topPtr;   if (origChainPtr == nullptr) topPtr = nullptr; // Original stack is empty else { // Copy first node topPtr = new Node<ItemType>(); topPtr->setItem(origChainPtr->getItem());   // Point to last node in new chain Node<ItemType>* newChainPtr = topPtr;   // Advance original-chain pointer origChainPtr = origChainPtr->getNext();   // Copy remaining nodes while (origChainPtr != nullptr) { // Get next item from original chain ItemType nextItem = origChainPtr->getItem();   // Create a new node containing the next item Node<ItemType>* newNodePtr = new Node<ItemType>(nextItem);   // Link new node to end of new chain newChainPtr->setNext(newNodePtr);   // Advance pointer to new last node newChainPtr = newChainPtr->getNext();   // Advance original-chain pointer origChainPtr = origChainPtr->getNext(); } // end while   newChainPtr->setNext(nullptr); // Flag end of chain } // end if } // end copy constructor template<class ItemType> LinkedStack<ItemType>::~LinkedStack() { // Pop until stack is empty while (!isEmpty()) pop(); } // end destructor template<class ItemType> bool LinkedStack<ItemType>::isEmpty() const { return topPtr == nullptr; } // end isEmpty template<class ItemType> bool LinkedStack<ItemType>::push(const ItemType& newItem) { Node<ItemType>* newNodePtr = new Node<ItemType>(newItem, topPtr); topPtr = newNodePtr; newNodePtr = nullptr;   return true; } // end push template<class ItemType> bool LinkedStack<ItemType>::pop() { bool result = false; if (!isEmpty()) { // Stack is not empty; delete top Node<ItemType>* nodeToDeletePtr = topPtr; topPtr = topPtr->getNext();   // Return deleted node to system nodeToDeletePtr->setNext(nullptr); delete nodeToDeletePtr; nodeToDeletePtr = nullptr;   result = true; } // end if   return result; } // end pop template<class ItemType> ItemType LinkedStack<ItemType>::peek() const { assert(!isEmpty()); // Enforce precondition   // Stack is not empty; return top return topPtr->getItem(); } // end getTop // End of implementation file. Functions: #include <iostream> using namespace std; bool checkString(string s) { //variables to store the count of A and B   int countA=0, countB=0;   //create the instance of linked stack to hold characters   LinkedStack <char> stackObj= new LinkedStack(); //loop invariant int i=0; //push the characters of the string into the stack while(i<s.length()) { //push the character into the stack stackObj.push(s[i]); } //pop the characters from the stack while (!stackObj.isEmpty())   { //extract the top element char top=stackObj.peek();   //if the character is A increment count of A if (top =='A') countA++; //if the character is B increment count of B if(top=='B') countB++; } //check the count of A and B, whether they are same   if(countA==countB)   return true;   else   return false; } bool checkStringb(string s) {   //variables to store the count of A and B   int countA=0, countB=0;   //create the instances of linked stack to hold characters   LinkedStack <char> stackObj1= new LinkedStack();   LinkedStack <char> stackObj2= new LinkedStack();   //loop invariant   int i=0;   //push the characters of the string into the stackObj1   while(i<s.length())   {   //push the character into the stack   stackObj1.push(s[i]);   }   //Create the copy of stack   LinkedStack <char> stackObj3= new LinkedStack(stackObj1);   //create the reverse string stack using stackObj3   //pop the characters from the stack   while (!stackObj3.isEmpty()) { //extract the top element char top=stackObj3.peek(); //push into the reverse stack stackObj2.push(top); //pop the top   stackObj2.pop(); } int count=0; //The while loop to check the stack contents while (!stackObj1.isEmpty() && !stackObj1.isEmpty()) { //extract the top element of stack 1 char top1=stackObj1.peek(); //extract the top element of stack 1 char top2=stackObj2.peek(); //pop the stacks stackObj2.pop(); stackObj1.pop(); if (top2=='A') if(top1!='B') return false; count++; if (top2=='B') break; } //check the count of A is half the string if(count==(s.length()/2)) return true; else return false; } int main() { return 0; }

    Expert Answer

     
    a) Pseudo Code: function whether_string_is_in_L(str){

    (C++ Facts Structure) Having problems with ths adjudication, I’m reputed to transcribe a pseudoadjudication part that uses LinkedStack to particularize whether a string is in the language L, where

    a. L = {s : s contains correspondent collection of A’s and B’s}

    b. L = {s : s is of the make An Bn for some n 0}

    and creat a deep.

    LinkedStack:

    template<class AceType>

    class StackInterface

    {

    public:

    /** Sees whether this stack is vacuity.

    @yield True if the stack is vacuity, or deceptive if referable. */

    virtual bool isEmpty() const = 0;

     

    /** Adds a novellightlight memorandum to the culmination of this stack.

    @post If the action was lucky, novellightMemorandum is at the culmination of the stack.

    @param novellightMemorandum The sight to be adventitious as a novellightlight memorandum.

    @yield True if the analysis is lucky or deceptive if referable. */

    virtual bool propel(const AceType& novellightEntry) = 0;

     

    /** Removes the culmination of this stack.

    @post If the action was lucky, the culmination of the stack

    has been removed.

    @yield True if the opposition is lucky or deceptive if referable. */

    virtual bool explode() = 0;

     

    /** Yields the culmination of this stack.

    @pre The stack is referable vacuity.

    @post The culmination of the stack has been yielded, and

    the stack is unnatural.

    @yield The culmination of the stack. */

    virtual AceType peek() const = 0;

    }; // object StackInterface

    //#endif

    //////////////////////////////////////////////////////////////

    template<class AceType>

    class Node

    {

    private:

    ItemType ace; // A facts ace

    Node<ItemType>* direct; // Pointer to direct node

     

    public:

    Node();

    Node(const AceType& anItem);

    Node(const AceType& anItem, Node<ItemType>* directNodePtr);

    void setItem(const AceType& anItem);

    void setNext(Node<ItemType>* directNodePtr);

    ItemType getItem() const ;

    Node<ItemType>* getNext() const ;

    }; // object Node

    //#include “Node.cpp”

    //#endif

    // Created by Frank M. Carrano and Tim Henry.

    // Delineationright (c) 2013 __Pearson Education__. Full rights cautious.

    /** @smooth Node.cpp

    Listing 4-2 */

    //#include “Node.h”

    #include <cstddef>

    template<class AceType>

    Node<ItemType>::Node() : direct(nullptr)

    {

    } // object defect constructor

    template<class AceType>

    Node<ItemType>::Node(const AceType& anItem) : ace(anItem), direct(nullptr)

    {

    } // object constructor

    template<class AceType>

    Node<ItemType>::Node(const AceType& anItem, Node<ItemType>* directNodePtr) :

    item(anItem), direct(nextNodePtr)

    {

    } // object constructor

    template<class AceType>

    void Node<ItemType>::setItem(const AceType& anItem)

    {

    ace = anItem;

    } // object setItem

    template<class AceType>

    void Node<ItemType>::setNext(Node<ItemType>* directNodePtr)

    {

    direct = directNodePtr;

    } // object setNext

    template<class AceType>

    ItemType Node<ItemType>::getItem() const

    {

    yield ace;

    } // object getItem

    template<class AceType>

    Node<ItemType>* Node<ItemType>::getNext() const

    {

    yield direct;

    } // object getNext

    //////////////////////////////////////////////////////////////

    //#ifndef _LINKED_STACK

    //#define _LINKED_STACK

    //#include “StackInterface.h”

    //#include “Node.h”

    template<class AceType>

    class LinkedStack : referableorious StackInterface<ItemType>

    {

    private:

    Node<ItemType>* culminationPtr; // Pointer to highest node in the chain;

    // this node contains the stack’s culmination

     

    public:

    // Constructors and destructor:

    LinkedStack(); // Defect constructor

    LinkedStack(const LinkedStack<ItemType>& aStack);// Delineation constructor

    virtual ~LinkedStack(); // Destructor

     

    // Stack actions:

    bool isEmpty() const;

    bool propel(const AceType& novellightItem);

    bool explode();

    ItemType peek() const;

    }; // object LinkedStack

    //#include “LinkedStack.cpp”

    //#endif

    ///////////////////////////////////////////////////////////////

    //#include <cassert> // For assert

    //#include “LinkedStack.h” // Header smooth

    template<class AceType>

    LinkedStack<ItemType>::LinkedStack() : culminationPtr(nullptr)

    {

    } // object defect constructor

    template<class AceType>

    LinkedStack<ItemType>::LinkedStack(const LinkedStack<ItemType>& aStack)

    {

    // Point to nodes in primordial chain

    Node<ItemType>* origChainPtr = aStack.topPtr;

     

    if (origChainPtr == nullptr)

    topPtr = nullptr; // Primordial stack is vacuity

    else

    {

    // Delineation highest node

    topPtr = novellightlight Node<ItemType>();

    topPtr->setItem(origChainPtr->getItem());

     

    // Point to developed node in novellightlight chain

    Node<ItemType>* novellightChainPtr = culminationPtr;

     

    // Advance primordial-chain pointer

    origChainPtr = origChainPtr->getNext();

     

    // Delineation retaining nodes

    period (origChainPtr != nullptr)

    {

    // Get direct ace from primordial chain

    ItemType directAce = origChainPtr->getItem();

     

    // Create a novellightlight node containing the direct ace

    Node<ItemType>* novellightNodePtr = novellightlight Node<ItemType>(nextItem);

     

    // Link novellightlight node to object of novellightlight chain

    newChainPtr->setNext(newNodePtr);

     

    // Advance pointer to novellightlight developed node

    newChainPtr = novellightChainPtr->getNext();

     

    // Advance primordial-chain pointer

    origChainPtr = origChainPtr->getNext();

    } // object period

     

    newChainPtr->setNext(nullptr); // Flag object of chain

    } // object if

    } // object delineation constructor

    template<class AceType>

    LinkedStack<ItemType>::~LinkedStack()

    {

    // Explode until stack is vacuity

    period (!isEmpty())

    pop();

    } // object destructor

    template<class AceType>

    bool LinkedStack<ItemType>::isEmpty() const

    {

    yield culminationPtr == nullptr;

    } // object isEmpty

    template<class AceType>

    bool LinkedStack<ItemType>::push(const AceType& novellightItem)

    {

    Node<ItemType>* novellightNodePtr = novellightlight Node<ItemType>(newItem, culminationPtr);

    topPtr = novellightNodePtr;

    newNodePtr = nullptr;

     

    yield true;

    } // object propel

    template<class AceType>

    bool LinkedStack<ItemType>::pop()

    {

    bool conclusion = deceptive;

    if (!isEmpty())

    {

    // Stack is referable vacuity; delete culmination

    Node<ItemType>* nodeToDeletePtr = culminationPtr;

    topPtr = culminationPtr->getNext();

     

    // Yield deleted node to system

    nodeToDeletePtr->setNext(nullptr);

    delete nodeToDeletePtr;

    nodeToDeletePtr = nullptr;

     

    conclusion = true;

    } // object if

     

    yield conclusion;

    } // object explode

    template<class AceType>

    ItemType LinkedStack<ItemType>::peek() const

    {

    assert(!isEmpty()); // Enforce precondition

     

    // Stack is referable vacuity; yield culmination

    yield culminationPtr->getItem();

    } // object getTop

    // Object of implementation smooth.

    Functions:

    #include <iostream>

    using namespace std;

    bool impedeString(string s)

    {

    //variables to treasury the number of A and B

     

    int numberA=0, numberB=0;

     

    //create the persuasion of linked stack to delay reputations

     

    LinkedStack <char> stackObj= novellightlight LinkedStack();

    //loop invariant

    int i=0;

    //propel the reputations of the string into the stack

    while(i<s.length())

    {

    //propel the reputation into the stack

    stackObj.push(s[i]);

    }

    //explode the reputations from the stack

    period (!stackObj.isEmpty())

     

    {

    //extract the culmination atom

    char culmination=stackObj.peek();

     

    //if the reputation is A increment number of A

    if (culmination ==’A’)

    countA++;

    //if the reputation is B increment number of B

    if(top==’B’)

    countB++;

    }

    //impede the number of A and B, whether they are same

     

    if(countA==countB)

     

    yield true;

     

    else

     

    yield deceptive;

    }

    bool impedeStringb(string s)

    {

     

    //variables to treasury the number of A and B

     

    int numberA=0, numberB=0;

     

    //create the persuasions of linked stack to delay reputations

     

    LinkedStack <char> stackObj1= novellightlight LinkedStack();

     

    LinkedStack <char> stackObj2= novellightlight LinkedStack();

     

    //loop invariant

     

    int i=0;

     

    //propel the reputations of the string into the stackObj1

     

    while(i<s.length())

     

    {

     

    //propel the reputation into the stack

     

    stackObj1.push(s[i]);

     

    }

     

    //Create the delineation of stack

     

    LinkedStack <char> stackObj3= novellightlight LinkedStack(stackObj1);

     

    //create the inversion string stack using stackObj3

     

    //explode the reputations from the stack

     

    period (!stackObj3.isEmpty())

    {

    //extract the culmination atom

    char culmination=stackObj3.peek();

    //propel into the inversion stack

    stackObj2.push(top);

    //explode the culmination

     

    stackObj2.pop();

    }

    int number=0;

    //The period loop to impede the stack contents

    period (!stackObj1.isEmpty() && !stackObj1.isEmpty())

    {

    //extract the culmination atom of stack 1

    char culmination1=stackObj1.peek();

    //extract the culmination atom of stack 1

    char culmination2=stackObj2.peek();

    //explode the stacks

    stackObj2.pop();

    stackObj1.pop();

    if (top2==’A’)

    if(top1!=’B’)

    yield deceptive;

    count++;

    if (top2==’B’)

    break;

    }

    //impede the number of A is half the string

    if(count==(s.length()/2))

    yield true;

    else

    yield deceptive;

    }

    int deep()

    {

    yield 0;

    }

    Expert Apology

     

    a)

    Pseudo Adjudication:

    part whether_string_is_in_L(str){

    initialize a stack

    iterate balance full the char of the string
    if char is ‘a’ or ‘b’ {
    if the stack is vacuity and
    propel ‘a’ or ‘b’
    else
    developed = peek culmination of stack
    if developed == floating char{
    propel floating char in stack
    }else{
    explode from the stack
    }
    }

    Executable Adjudication:

    #include <iostream>
    #include <stack>
    #include <vector>
    #include <deque>
    using namespace std;
    #include <string>

    int whether_string_is_in_L(string s){
    stack<char> mystack;

    for (int i = 0; i < s.length(); ++i)
    {
    if(s[i] == ‘a’ || s[i] == ‘b’){

    if( mystack.empty() ) mystack.push(s[i]);
    else{

    if(s[i] == mystack.top()){
    mystack.push(s[i]);
    }else{
    mystack.pop();
    }
    }
    }
    }

    if(mystack.empty()){
    cout << “string ” << s << ” belongs to nativity L” << objectl;
    }else{
    cout << “string ” << s << ” does referable belongs to nativity L” << objectl;
    }

    yield 1;
    }

    int deep ()
    {

    string s = “aabssssaawss”;

    whether_string_is_in_L(s);

    s = “a”;

    whether_string_is_in_L(s);

    s = “b”;

    whether_string_is_in_L(s);

    s = “ab”;

    whether_string_is_in_L(s);

    s = “ababab”;

    whether_string_is_in_L(s);

    s = “ababaaaa”;

    whether_string_is_in_L(s);

    yield 0;
    }

    Output: