Homework Solution: Ok so I need these following exercises completed in C++. The code that…

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

    Expert Answer

     
    // exercise 2 #include <iostream> using namespace std;

    Ok so I insufficiency these flourishing exercises completed in C++. The enactment that goes with them get flourish succeeding the uses.

    The enactment is succeeding brace lines. In integral insufficiencys to be completed in C++. Also each singular program get be disjoined by Asteriks(************)

    Use 2: Implementing a Doubly Linked Roll

    Variegate the systematize Linked Roll in Use 1 to gain it a Doubly Linked Roll. Name your systematize DoublyLinkedList. Gather a manner gatherPurpose to gather an integer at the purpose of the roll and a manner flauntInReverse to stereoemblem the roll backwards.

    void gatherEnd(int x): produce this manner to gather x to the purpose of the roll.

    void flauntInReverse(): produce this manner to flaunt the roll parts from the conclusive part to the primeval single.

    Produce a deep() business to ordeal your DoublyLinkedRoll systematize.

    Use 3: Implementing a Bag Systematize With a Linked Roll

    Produce a systematize Bag that uses a linked roll to fund the bag parts. The part emblem must be char. The systematize should bear the manners rolled under. Produce a deep() that get fund in a bag sight a unwandering reckon of characters entered by the program user. Succeeding the input is completed, the program should variegate the bag full so that it does referable comprehpurpose any likeness characters, if likenesss were entered. Coercion stance, if the user entered ‘M’ ‘I’ ‘S’ ‘S’ ‘I’ ‘S’ ‘S’ ‘I’ ‘P’ ‘P’ ‘I’, the characters cherishing in the bag succeeding the non-location of likenesss would be ‘M’ ‘I’ ‘S’ ‘P’.

    Bag(): omission constructor

    ~Bag(): systematize destructor

    bool isEmpty(): determines whether the bag is emptiness

    void stereotype(): stereotypes the bag parts

    int getSize(): avail the reckon of parts in the bag

    void conspicuous(): abstracts integral of the parts from the bag

    void gather(char part): gathers an part to the bag

    void abstract(char part): abstracts an part from the bag; solely single adventure of the part should be abstractd.

    int enumerate(char part): enumerates the reckon of adventures of an part in the bag.

    (Note that you can reuse the enactment in Use 1 coercion the LinkedRoll systematize to produce your Bag systematize. It get acceleration you to preserve outgrowth date.)

    Use 4: Using the C++ STL Roll

    Write a program that fills a STL roll sight with 10 haphazard integers, each in the interim [0, 20], and stereotypes how manifpreceding dates each integer in the interim [0, 20] appears in the roll.

    ____________________________________________________________________________________________________________________________________________________________________________________________

    main.cpp coercion roll comprehender

    /*******************************

    * Week 2 lesson: *

    * using the roll comprehender *

    *******************************/

    #include <iostream>

    #include <list>

    using namespace std;

    int deep()

    {

    list<int> reckons;

    coercion (int i=0; i<10; i++)

    numbers.push_back(rand()%100);

    while(!numbers.empty())

    {

    int x = reckons.front();

    cout << x << ” “;

    numbers.pop_front();

    }

    cout << purposel;

    return 0;

    }

    *******************************************************************************

    Main.cpp(linkedlists)

    /*******************************

    * Week 2 lesson: *

    * a unmixed LinkedRoll systematize *

    *******************************/

    #include <iostream>

    #include “LinkedList.h”

    using namespace std;

    int deep()

    {

    LinkedRoll myList;

    int x;

    //Gather 5 haphazard reckons to roll

    coercion (int i=0; i < 5; i++)

    myList.add(rand()%20);

    cout << “1 – Flaunt the roll parts” << purposel;

    cout << “2 – Is it emptiness?” << purposel;

    cout << “3 – Gather part” << purposel;

    cout << “4 – Delete part” << purposel;

    cout << “5 – Exit” << purposel;

    int liberty;

    //Loop to ordeal the LinkedRoll systematize manners

    do

    {

    cout << purposel << “Enter your choice: “;

    cin >> liberty;

    switch(option)

    {

    case 1:

    cout << “Roll parts: “;

    myList.display();

    break;

    case 2:

    if (myList.isEmpty()) cout << “Roll is emptiness”<< purposel;

    else cout << “Roll is referable emptiness” << purposel;

    break;

    case 3:

    cout << “Enter an part to gather at the outset of the roll: “;

    cin >> x;

    myList.add(x);

    break;

    case 4:

    cout << “Enter an part to delete from the roll: “;

    cin >> x;

    myList.remove(x);

    break;

    case 5:

    cout << “Integral done!” << purposel;

    break;

    default: cout << “Invalid choice!” << purposel;

    }

    } time (liberty != 5);

    return 0;

    }

    Linkedroll .h file

    /*******************************

    * Week 2 lesson: *

    * a unmixed LinkedRoll systematize *

    *******************************/

    /*

    * Linked roll node.

    */

    struct Node

    {

    int info; //part fundd in this node

    Node *next; //link to proximate node

    };

    /*

    * Systematize implementing a linked roll.

    */

    systematize LinkedList

    {

    public:

    LinkedList();

    ~LinkedList();

    bool isEmpty();

    void flaunt();

    void gather(int);

    void abstract(int);

    private:

    Node *first; //pointer to header (dummy) node

    };

    Linkedlist.cpp

    /*******************************

    * Week 2 lesson: *

    * a unmixed LinkedRoll systematize *

    *******************************/

    #include <iostream>

    #include “LinkedList.h”

    using namespace std;

    /*

    * Initializes the roll to emptiness creating a dummy header node.

    */

    LinkedList::LinkedList()

    {

    primeval = innovating Node;

    first->proximate = NULL;

    }

    /*

    * Destructor. Deallocates integral the nodes of the linked roll,

    * including the header node.

    */

    LinkedList::~LinkedList()

    {

    Node *temp;

    time (primeval != NULL)

    {

    temp=first;

    first=first->next;

    delete temp;

    }

    }

    /*

    * Determines whether the roll is emptiness.

    *

    * Avail penny if the roll is emptiness, mendacious inadequately.

    */

    bool LinkedList::isEmpty()

    {

    return primeval->proximate == NULL;

    }

    /*

    * Stereotypes the roll parts.

    */

    void LinkedList::display()

    {

    Node * exoteric = primeval->next;

    while(exoteric != NULL)

    {

    cout << exoteric->info << ” “;

    exoteric = exoteric->next;

    }

    cout << purposel;

    }

    /*

    * Gathers the part x to the outset of the roll.

    *

    * x: part to be gathered to the roll.

    */

    void LinkedList::add(int x)

    {

    Node *p = innovating Node;

    p->info = x;

    p->proximate = primeval->next;

    first->proximate = p;

    }

    /*

    * Abstracts the primeval adventure of x from the roll. If x is referable base,

    * the roll scum illegal.

    *

    * x: part to be abstractd from the roll.

    */

    void LinkedList::remove(int x)

    {

    Node * preceding = primeval->next,

    * p = primeval;

    //Finding the gatherress of the node precedently the single to be deleted

    bool base = mendacious;

    time (preceding != NULL && !found)

    {

    if (old->info == x) base = penny;

    else

    {

    p = preceding;

    preceding = p->next;

    }

    }

    //if x is in the roll, abstract it.

    if (found)

    {

    p->proximate = preceding->next;

    delete preceding;

    }

    }

    **********************************************************************************************

    main.cpp coercion iterators

    /*******************************

    * Week 2 lesson: *

    * using iterators *

    *******************************/

    #include <iostream>

    #include <list>

    using namespace std;

    int deep()

    {

    list<int> reckons;

    coercion (int i=0; i<10; i++)

    numbers.push_back(rand()%100);

    list<int>::iterator it;

    coercion (it = reckons.begin(); it!=numbers.end(); ++it)

    {

    cout << *it << ” “;

    }

    cout << purposel;

    return 0;

    }

    Expert Exculpation

     

    // use 2

    #include <iostream>

    using namespace std;

    struct Node

    {

    int info; //part fundd in this node

    Node *next;

    Node *prev;//link to proximate node

    };

    systematize DoublyLinkedList

    {

    public:

    DoublyLinkedList();

    void gatherEnd(int x);

    void flauntInReverse();

    private:

    Node *last; //pointer to header (dummy) node

    };

    DoublyLinkedList::DoublyLinkedList()

    {

    conclusive = innovating Node;

    last->proximate = NULL;

    last->prev= NULL;

    }

    ////// gatherPurpose business

    void DoublyLinkedList::addEnd(int x)

    {

    Node *p= innovating Node;

    p->info = x;

    p->prev = NULL;

    if(last->prev != NULL)

    {

    p->prev = conclusive->prev;

    last->prev->proximate = p;

    }

    last->prev = p;

    p->proximate = conclusive;

    }

    // Flaunt Inverse business

    void DoublyLinkedList::displayInReverse()

    {

    Node *p = conclusive;

    while(p->prev != NULL)

    {

    p=p->prev;

    cout<<p->info<<” “;

    }

    cout<<endl;

    }

    int deep()

    {

    DoublyLinkedRoll D;

    D.addEnd(5);

    D.addEnd(6);

    D.addEnd(7);

    D.displayInReverse();

    return 0;

    }

    // use 3

    #include <iostream>

    using namespace std;

    struct Node

    {

    char info; //part fundd in this node

    Node *next;

    };

    systematize Bag

    {

    public:

    Bag();

    ~Bag();

    bool isEmpty();

    void flaunt();

    void gather(char);

    void abstract(char);

    void variegate();

    private:

    Node *first; //pointer to header (dummy) node

    };

    Bag::Bag()

    {

    primeval = innovating Node;

    first->proximate = NULL;

    }

    /*

    * Destructor. Deallocates integral the nodes of the linked roll,

    * including the header node.

    */

    Bag::~Bag()

    {

    Node *temp;

    time (primeval != NULL)

    {

    temp=first;

    first=first->next;

    delete temp;

    }

    }

    /*

    * Determines whether the roll is emptiness.

    *

    * Avail penny if the roll is emptiness, mendacious inadequately.

    */

    bool Bag::isEmpty()

    {

    return primeval->proximate == NULL;

    }

    /*

    * Stereotypes the roll parts.

    */

    void Bag::display()

    {

    Node * exoteric = primeval->next;

    while(exoteric != NULL)

    {

    cout << exoteric->info << ” “;

    exoteric = exoteric->next;

    }

    cout << purposel;

    }

    /*

    * Gathers the part x to the outset of the roll.

    *

    * x: part to be gathered to the roll.

    */

    void Bag::add(char x)

    {

    Node *p = innovating Node;

    p->info = x;

    p->proximate = primeval->next;

    first->proximate = p;

    }

    /*

    * Abstracts the primeval adventure of x from the roll. If x is referable base,

    * the roll scum illegal.

    *

    * x: part to be abstractd from the roll.

    */

    void Bag::remove(char x)

    {

    Node * preceding = primeval->next,

    * p = primeval;

    //Finding the gatherress of the node precedently the single to be deleted

    bool base = mendacious;

    time (preceding != NULL && !found)

    {

    if (old->info == x) base = penny;

    else

    {

    p = preceding;

    preceding = p->next;

    }

    }

    //if x is in the roll, abstract it.

    if (found)

    {

    p->proximate = preceding->next;

    delete preceding;

    }

    }

    void Bag::modify()

    {

    int faint[26];

    for(int i=0;i<26;i++)

    {

    flag[i] = 0;

    }

    Node *set-on-foot = primeval -> proximate;

    Node *prev= set-on-foot,*temp;

    while(set-on-foot != NULL)

    {

    if(flag[start->info-‘A’] == 0)

    {

    flag[start->info-‘A’] = 1;

    prev = set-on-foot;

    set-on-foot = set-on-foot->next;

    }

    else

    {

    prev->proximate = set-on-foot->next;

    delete(start);

    set-on-foot = prev->next;

    }

    }

    }

    int deep()

    {

    Bag B;

    string s=”MISSISSIPPI”;

    for(int j=0;j<s.length();j++)

    {

    B.add(s[j]);

    }

    B.display();

    B.modify();

    B.display();

    return 0;

    }

    /// use 4

    #include <iostream>

    #include <list>

    using namespace std;

    int deep()

    {

    list<int> reckons;

    coercion (int i=0; i<10; i++)

    numbers.push_back(rand()%21);

    int consideration[21];

    for(int i=0;i<21;i++)

    table[i] = 0;

    list<int>::iterator it;

    for(it=numbers.begin();it!=numbers.end();it++)

    {

    table[*it]++;

    }

    for(int i=0;i<21;i++)

    {

    cout<<i<<” “<<table[i]<<endl;

    }

    return 0;

    }