Ok so I need these following exercises completed in C++. The code that goes with them will follow after the exercises.
The code is after two lines. In all needs to be completed in C++. Also each individual program will be separated by Asteriks(************)
Exercise 2: Implementing a Doubly Linked List
Modify the class Linked List in Exercise 1 to make it a Doubly Linked List. Name your class DoublyLinkedList. Add a method addEnd to add an integer at the end of the list and a method displayInReverse to print the list backwards.
void addEnd(int x): create this method to add x to the end of the list.
void displayInReverse(): create this method to display the list elements from the last item to the first one.
Create a main() function to test your DoublyLinkedList class.
Exercise 3: Implementing a Bag Class With a Linked List
Create a class Bag that uses a linked list to store the bag items. The item type must be char. The class should have the methods listed below. Create a main() that will store in a bag object a fixed number of characters entered by the program user. After the input is completed, the program should modify the bag content so that it does not contain any duplicate characters, if duplicates were entered. For example, if the user entered 'M' 'I' 'S' 'S' 'I' 'S' 'S' 'I' 'P' 'P' 'I', the characters remaining in the bag after the removal of duplicates would be 'M' 'I' 'S' 'P'.
Bag(): default constructor
~Bag(): class destructor
bool isEmpty(): determines whether the bag is empty
void print(): prints the bag elements
int getSize(): returns the number of items in the bag
void clear(): removes all of the items from the bag
void add(char item): adds an item to the bag
void remove(char item): removes an item from the bag; only one occurrence of the item should be removed.
int count(char item): counts the number of occurrences of an item in the bag.
(Note that you can reuse the code in Exercise 1 for the LinkedList class to create your Bag class. It will help you to save development time.)
Exercise 4: Using the C++ STL List
Write a program that fills a STL list object with 10 random integers, each in the interval [0, 20], and prints how many times each integer in the interval [0, 20] appears in the list.
____________________________________________________________________________________________________________________________________________________________________________________________
main.cpp for list container
/*******************************
* Week 2 lesson: *
* using the list container *
*******************************/
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> numbers;
for (int i=0; i<10; i++)
numbers.push_back(rand()%100);
while(!numbers.empty())
{
int x = numbers.front();
cout << x << " ";
numbers.pop_front();
}
cout << endl;
return 0;
}
*******************************************************************************
Main.cpp(linkedlists)
/*******************************
* Week 2 lesson: *
* a simple LinkedList class *
*******************************/
#include <iostream>
#include "LinkedList.h"
using namespace std;
int main()
{
LinkedList myList;
int x;
//Add 5 random numbers to list
for (int i=0; i < 5; i++)
myList.add(rand()%20);
cout << "1 - Display the list elements" << endl;
cout << "2 - Is it empty?" << endl;
cout << "3 - Add element" << endl;
cout << "4 - Delete element" << endl;
cout << "5 - Exit" << endl;
int option;
//Loop to test the LinkedList class methods
do
{
cout << endl << "Enter your choice: ";
cin >> option;
switch(option)
{
case 1:
cout << "List elements: ";
myList.display();
break;
case 2:
if (myList.isEmpty()) cout << "List is empty"<< endl;
else cout << "List is not empty" << endl;
break;
case 3:
cout << "Enter an element to add at the beginning of the list: ";
cin >> x;
myList.add(x);
break;
case 4:
cout << "Enter an element to delete from the list: ";
cin >> x;
myList.remove(x);
break;
case 5:
cout << "All done!" << endl;
break;
default: cout << "Invalid choice!" << endl;
}
} while (option != 5);
return 0;
}
Linkedlist .h file
/*******************************
* Week 2 lesson: *
* a simple LinkedList class *
*******************************/
/*
* Linked list node.
*/
struct Node
{
int info; //element stored in this node
Node *next; //link to next node
};
/*
* Class implementing a linked list.
*/
class LinkedList
{
public:
LinkedList();
~LinkedList();
bool isEmpty();
void display();
void add(int);
void remove(int);
private:
Node *first; //pointer to header (dummy) node
};
Linkedlist.cpp
/*******************************
* Week 2 lesson: *
* a simple LinkedList class *
*******************************/
#include <iostream>
#include "LinkedList.h"
using namespace std;
/*
* Initializes the list to empty creating a dummy header node.
*/
LinkedList::LinkedList()
{
first = new Node;
first->next = NULL;
}
/*
* Destructor. Deallocates all the nodes of the linked list,
* including the header node.
*/
LinkedList::~LinkedList()
{
Node *temp;
while (first != NULL)
{
temp=first;
first=first->next;
delete temp;
}
}
/*
* Determines whether the list is empty.
*
* Returns true if the list is empty, false otherwise.
*/
bool LinkedList::isEmpty()
{
return first->next == NULL;
}
/*
* Prints the list elements.
*/
void LinkedList::display()
{
Node * current = first->next;
while(current != NULL)
{
cout << current->info << " ";
current = current->next;
}
cout << endl;
}
/*
* Adds the element x to the beginning of the list.
*
* x: element to be added to the list.
*/
void LinkedList::add(int x)
{
Node *p = new Node;
p->info = x;
p->next = first->next;
first->next = p;
}
/*
* Removes the first occurrence of x from the list. If x is not found,
* the list remains unchanged.
*
* x: element to be removed from the list.
*/
void LinkedList::remove(int x)
{
Node * old = first->next,
* p = first;
//Finding the address of the node before the one to be deleted
bool found = false;
while (old != NULL && !found)
{
if (old->info == x) found = true;
else
{
p = old;
old = p->next;
}
}
//if x is in the list, remove it.
if (found)
{
p->next = old->next;
delete old;
}
}
**********************************************************************************************
main.cpp for iterators
/*******************************
* Week 2 lesson: *
* using iterators *
*******************************/
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> numbers;
for (int i=0; i<10; i++)
numbers.push_back(rand()%100);
list<int>::iterator it;
for (it = numbers.begin(); it!=numbers.end(); ++it)
{
cout << *it << " ";
}
cout << endl;
return 0;
}
Homework Solution: Ok so I need these following exercises completed in C++. The code that goes with them will foll…
Ok so I deficiency these behindcited exercises completed in C++. The order that goes with them gain flourish behind the exercises.
The order is behind couple lines. In entire deficiencys to be completed in C++. Also each specific program gain be separated by Asteriks(************)
Exercise 2: Implementing a Doubly Linked Inventory
Variegate the collocate Linked Inventory in Exercise 1 to constitute it a Doubly Linked Inventory. Name your collocate DoublyLinkedList. Subjoin a mode subjoinDesign to subjoin an integer at the design of the inventory and a mode exhibitInReverse to stereotype the inventory backwards.
void subjoinEnd(int x): educe this mode to subjoin x to the design of the inventory.
void exhibitInReverse(): educe this mode to exhibit the inventory components from the definite part to the primitive individual.
Educe a ocean() part to ordeal your DoublyLinkedInventory collocate.
Exercise 3: Implementing a Bag Collocate With a Linked Inventory
Educe a collocate Bag that uses a linked inventory to treasury the bag parts. The part stamp must be char. The collocate should accept the modes inventoryed beneath. Educe a ocean() that gain treasury in a bag design a urban estimate of characters entered by the program user. Behind the input is completed, the program should variegate the bag full so that it does referable include any transcript characters, if transcripts were entered. Control fruit, if the user entered ‘M’ ‘I’ ‘S’ ‘S’ ‘I’ ‘S’ ‘S’ ‘I’ ‘P’ ‘P’ ‘I’, the characters fostering in the bag behind the analysis of transcripts would be ‘M’ ‘I’ ‘S’ ‘P’.
Bag(): want constructor
~Bag(): collocate destructor
bool isEmpty(): determines whether the bag is emptiness
void stereotype(): stereotypes the bag components
int getSize(): income the estimate of parts in the bag
void acquitted(): abstracts entire of the parts from the bag
void subjoin(char part): subjoins an part to the bag
void abstract(char part): abstracts an part from the bag; simply individual affair of the part should be abstractd.
int enumerate(char part): enumerates the estimate of affairs of an part in the bag.
(Note that you can reuse the order in Exercise 1 control the LinkedInventory collocate to educe your Bag collocate. It gain aid you to reserve fruit age.)
Exercise 4: Using the C++ STL Inventory
Write a program that fills a STL inventory design with 10 haphazard integers, each in the interim [0, 20], and stereotypes how sundry ages each integer in the interim [0, 20] appears in the inventory.
____________________________________________________________________________________________________________________________________________________________________________________________
main.cpp control inventory includeer
/*******************************
* Week 2 lesson: *
* using the inventory includeer *
*******************************/
#include <iostream>
#include <list>
using namespace std;
int ocean()
{
list<int> estimates;
control (int i=0; i<10; i++)
numbers.push_back(rand()%100);
while(!numbers.empty())
{
int x = estimates.front();
cout << x << ” “;
numbers.pop_front();
}
cout << designl;
return 0;
}
*******************************************************************************
Main.cpp(linkedlists)
/*******************************
* Week 2 lesson: *
* a sincere LinkedInventory collocate *
*******************************/
#include <iostream>
#include “LinkedList.h”
using namespace std;
int ocean()
{
LinkedInventory myList;
int x;
//Subjoin 5 haphazard estimates to inventory
control (int i=0; i < 5; i++)
myList.add(rand()%20);
cout << “1 – Exhibit the inventory components” << designl;
cout << “2 – Is it emptiness?” << designl;
cout << “3 – Subjoin component” << designl;
cout << “4 – Delete component” << designl;
cout << “5 – Exit” << designl;
int discretion;
//Loop to ordeal the LinkedInventory collocate modes
do
{
cout << designl << “Enter your choice: “;
cin >> discretion;
switch(option)
{
case 1:
cout << “Inventory components: “;
myList.display();
break;
case 2:
if (myList.isEmpty()) cout << “Inventory is emptiness”<< designl;
else cout << “Inventory is referable emptiness” << designl;
break;
case 3:
cout << “Enter an component to subjoin at the preface of the inventory: “;
cin >> x;
myList.add(x);
break;
case 4:
cout << “Enter an component to delete from the inventory: “;
cin >> x;
myList.remove(x);
break;
case 5:
cout << “Entire done!” << designl;
break;
default: cout << “Invalid choice!” << designl;
}
} occasion (discretion != 5);
return 0;
}
Linkedinventory .h file
/*******************************
* Week 2 lesson: *
* a sincere LinkedInventory collocate *
*******************************/
/*
* Linked inventory node.
*/
struct Node
{
int info; //component treasuryd in this node
Node *next; //link to proximate node
};
/*
* Collocate implementing a linked inventory.
*/
collocate LinkedList
{
public:
LinkedList();
~LinkedList();
bool isEmpty();
void exhibit();
void subjoin(int);
void abstract(int);
private:
Node *first; //pointer to header (dummy) node
};
Linkedlist.cpp
/*******************************
* Week 2 lesson: *
* a sincere LinkedInventory collocate *
*******************************/
#include <iostream>
#include “LinkedList.h”
using namespace std;
/*
* Initializes the inventory to emptiness creating a dummy header node.
*/
LinkedList::LinkedList()
{
primitive = strange Node;
first->proximate = NULL;
}
/*
* Destructor. Deallocates entire the nodes of the linked inventory,
* including the header node.
*/
LinkedList::~LinkedList()
{
Node *temp;
occasion (primitive != NULL)
{
temp=first;
first=first->next;
delete temp;
}
}
/*
* Determines whether the inventory is emptiness.
*
* Income gentleman if the inventory is emptiness, fiction otherwise.
*/
bool LinkedList::isEmpty()
{
return primitive->proximate == NULL;
}
/*
* Stereotypes the inventory components.
*/
void LinkedList::display()
{
Node * exoteric = primitive->next;
while(exoteric != NULL)
{
cout << exoteric->info << ” “;
exoteric = exoteric->next;
}
cout << designl;
}
/*
* Subjoins the component x to the preface of the inventory.
*
* x: component to be subjoined to the inventory.
*/
void LinkedList::add(int x)
{
Node *p = strange Node;
p->info = x;
p->proximate = primitive->next;
first->proximate = p;
}
/*
* Abstracts the primitive affair of x from the inventory. If x is referable root,
* the inventory dross illegal.
*
* x: component to be abstractd from the inventory.
*/
void LinkedList::remove(int x)
{
Node * senile-antique = primitive->next,
* p = primitive;
//Finding the subjoinress of the node anteriorly the individual to be deleted
bool root = fiction;
occasion (senile-antique != NULL && !found)
{
if (old->info == x) root = gentleman;
else
{
p = senile-antique;
senile-antique = p->next;
}
}
//if x is in the inventory, abstract it.
if (found)
{
p->proximate = senile-antique->next;
delete senile-antique;
}
}
**********************************************************************************************
main.cpp control iterators
/*******************************
* Week 2 lesson: *
* using iterators *
*******************************/
#include <iostream>
#include <list>
using namespace std;
int ocean()
{
list<int> estimates;
control (int i=0; i<10; i++)
numbers.push_back(rand()%100);
list<int>::iterator it;
control (it = estimates.begin(); it!=numbers.end(); ++it)
{
cout << *it << ” “;
}
cout << designl;
return 0;
}
Expert Reply
#include <cassert>
#include <cstdlib>
#include <iostream>
#include “node.h”
#include “LinkedList.h”
using namespace std;
namespace assign1
{
LinkedList::LinkedList()
{
head_ptr = NULL,
many_nodes = 0;
}
LinkedList::LinkedList(const LinkedList& commencement)
{
node *tail_ptr; //needed control discussion of inventory_copy
list_copy(source.head_ptr, head_ptr, tail_ptr);
many_nodes = commencement.many_nodes;
}
LinkedList::~LinkedList()
{
list_clear(head_ptr);
many_nodes = 0
}
size_stamp LinkedList::count(const value_type& target) const
{
size_stamp reply;
const node *cursor;
reply = 0;
cursor = inventory_search(head_ptr, target);
while(cursor!=NULL)
{
++answer;
cursor = cursor->get_link();
cursor = inventory_search(cursor,target);
}
return reply;
}
void LinkedList::list_head_insert(node* head_ptr, const node::value_stamp initiation)
53
{
list_head_insert(head_ptr,entry);
++many_nodes;
}
void LinkedList::list_tail_insert(node* tail_ptr, const node::value_type& initiation)
{
new_elem = strange node();
new_elem-> set_data(entry);
new_elem->set_link(NULL);
tail_ptr->set_link(new_elem);
tail_ptr = strange_elem;
++sundry nodes;
}
void operator +=(const LinkedList& subjoinend)
{
node *copy_head_ptr;
node *copy_tail_ptr;
if (addend.many_nodes > 0)
{
list_copy(Addend.head_ptr, copy_head_ptr, copy_tail_ptr);
copy_tail_ptr->set_link(head_ptr);
head_ptr = copy_head_ptr;
many_nodes += subjoinend.many_nodes;
}
}
}