Answered Essay: (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){

initialize a stack

iterate over all the char of the string
if char is ‘a’ or ‘b’ {
if the stack is empty and
push ‘a’ or ‘b’
else
last = peek top of stack
if last == current char{
push current char in stack
}else{
pop from the stack
}
}

Executable Code:

#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 family L” << endl;
}else{
cout << “string ” << s << ” does not belongs to family L” << endl;
}

return 1;
}

int main ()
{

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);

return 0;
}

Output:

Buy Essay
Calculate your paper price
Pages (550 words)
Approximate price: -

Help Me Write My Essay - Reasons:

Best Online Essay Writing Service

We strive to give our customers the best online essay writing experience. We Make sure essays are submitted on time and all the instructions are followed.

Our Writers are Experienced and Professional

Our essay writing service is founded on professional writers who are on stand by to help you any time.

Free Revision Fo all Essays

Sometimes you may require our writers to add on a point to make your essay as customised as possible, we will give you unlimited times to do this. And we will do it for free.

Timely Essay(s)

We understand the frustrations that comes with late essays and our writers are extra careful to not violate this term. Our support team is always engauging our writers to help you have your essay ahead of time.

Customised Essays &100% Confidential

Our Online writing Service has zero torelance for plagiarised papers. We have plagiarism checking tool that generate plagiarism reports just to make sure you are satisfied.

24/7 Customer Support

Our agents are ready to help you around the clock. Please feel free to reach out and enquire about anything.

Try it now!

Calculate the price of your order

Total price:
$0.00

How it works?

Follow these simple steps to get your paper done

Place your order

Fill in the order form and provide all details of your assignment.

Proceed with the payment

Choose the payment system that suits you most.

Receive the final file

Once your paper is ready, we will email it to you.

HOW OUR ONLINE ESSAY WRITING SERVICE WORKS

Let us write that nagging essay.

STEP 1

Submit Your Essay/Homework Instructions

By clicking on the "PLACE ORDER" button, tell us your requires. Be precise for an accurate customised essay. You may also upload any reading materials where applicable.

STEP 2

Pick A & Writer

Our ordering form will provide you with a list of writers and their feedbacks. At step 2, its time select a writer. Our online agents are on stand by to help you just in case.

STEP 3

Editing (OUR PART)

At this stage, our editor will go through your essay and make sure your writer did meet all the instructions.

STEP 4

Receive your Paper

After Editing, your paper will be sent to you via email.

× How can I help you?