Question

For this assignment you will create a stand-alone function, sort, that takes an UList<T> parameter and sorts it using the Bubble Sort algorithm. This sort function is to be placed in a file named sortBS.h and UList should be in a file named UList.h. The UML diagram for UList is given below:

UList<T>

#items: vector<T>

+UList(size_t=10)

+insert(const T&): void

+erase(const T&): bool

+find(const T&) const: bool

+size() const: size_t

+empty() const: bool

+friend operator << (ostream&, const UList<U>&): ostream&

+friend sort (UList<U>&): void

Submit sortBS.h and UList.hprior to the due date/time using the following form:

Answer 1

The required function sort() is as follows:

// Define the function to sort the list using

// bubble sort.

template <class U>

void sort (UList<U>& myList)

{

    // Start the loop to traverse the list.

    for (int i = 0; i < myList.size()-1; i++)

    {

        for (int j = 0; j < myList.size()-i-1; j++)

        {

            // Check if the values are in order or not.

            if (myList.items.at(j) > myList.items.at(j+1))

            {

                // Use a temporary variable to swap

                // the elements if they are not in order.

                U temp = myList.items.at(j);

                myList.items.at(j) = myList.items.at(j+1);

                myList.items.at(j+1) = temp;

            }

        }

    }

}

The complete executable code along with all the header files and main function is shown below:

Program screenshots:

UList.h

#ifndef ULIST_H #define ULIST_H // Include the required header files. #include <vector> %#3include <iostream> // Use the standard namespace. using namespace std; // Define the template. template <class T> class UList { protected: vector<T> items; public: // Define the constructor to set the size of the vector. UList <T>(size_t size = 10) { items.reserve(size); // Define the function to insert an element in the list. void insert (const T& item) { items.push_back(item);

// Define the function to remove an element from // list. bool erase (const T& item) { // Call the function to check if the element // is present in the list or not. if (find(item) == true) { int index = 0; // Start the loop to find the index of the // element to be removed. for (int i = 0; i < items.size(); i++) if (items.at(i) == item) { index = i; break; // Call the function to remove the element. items.erase(index); // Return true. return true; } // Return false if the element is not deleted. else return false; }

// Define the function to check if the element // is present in the list or not. bool find (const T& item) const { // Start the loop to traverse the list. for (int i = 0; i < items.size(); i++) { if (items.at(i) == { // Return true if the element is found. item) return true; // Otherwise, return false. return false; // Define the function to return the size of the list. size_t size() const { return items.size(); // Define the function to check if the list is // empty or not. bool empty() const { return items.empty(); } // Declare the friend functions with template. template <class U> friend ostream& operator « (ostream& out, const UList<U>& myList); template <class U> friend void sort (UList <U>&); };

// Define function to overload the << operator. template <class U> ostream& operator << (ostream& out, const UList <U>& myList) // Start the loop to travese the list. for (int i = 0; i < myList.items.size(); i++) { // Add the value to the object. out << myList.items.at (i) « "; // Return the object. return out; #endif

sortBS.h

#ifndef SORTBS_H #define SORTBS_H // Include the required header files. %#3include "UList.h" // Define the function to sort the list using // bubble sort. template <class U> void sort (UList<U>& myList) { // Start the loop to traverse the list. for (int i = 0; i < myList.size()-1; i++) { for (int j = 0; j < myList.size()-i-1; j++) { // Check if the values are in order or not. if (myList.items.at(j) > myList.items.at(j+1)) { // Use a temporary variable to swap // the elements if they are not in order. U temp = my List.items.at(j); myList.items.at(j) = myList.items.at(j+1); myList.items.at(j+1) = temp; #endif

main.cpp

// Include the required header files. %#3include <iostream> %#3include "UList.h" #include "sortBS.h" // Use the standard namespace. using namespace std; // Define the main() function. int main() { // Create an object of the class UList. UList<int> myList; // Enter few values in the list. my List.insert(40); myList.insert(20); my List.insert(30); myList.insert(10); // Display the initial list using the << operator. cout << "Initial list: "; cout <« myList « endl; // Call the function to sort the list using // bubble sort. sort(myList); // Display the sorted list. cout <« "Sorted list: "; cout <« myList « endl; // Return 0 and exit the code. return 0;

Sample output:

Initial list: 40 20 30 10 Sorted list: 10 20 30 40

Code to copy:

UList.h

#ifndef ULIST_H

#define ULIST_H

// Include the required header files.

#include <vector>

#include <iostream>

// Use the standard namespace.

using namespace std;

// Define the template.

template <class T>

class UList

{

    protected:

    vector<T> items;

    public:

    

    // Define the constructor to set the size of the vector.

    UList <T>(size_t size = 10)

    {

        items.reserve(size);

    }

    // Define the function to insert an element in the list.

    void insert (const T& item)

    {

        items.push_back(item);

    }

    // Define the function to remove an element from

    // list.

    bool erase (const T& item)

    {

        // Call the function to check if the element

        // is present in the list or not.

        if (find(item) == true)

        {

            int index = 0;

            // Start the loop to find the index of the

            // element to be removed.

            for (int i = 0; i < items.size(); i++)

            {

                if (items.at(i) == item)

                {

                    index = i;

                    break;

                }

            }

            // Call the function to remove the element.

            items.erase(index);

            // Return true.

            return true;

        }

        // Return false if the element is not deleted.

        else

        {

            return false;

        }

    }

    // Define the function to check if the element

    // is present in the list or not.

    bool find (const T& item) const

    {

        // Start the loop to traverse the list.

        for (int i = 0; i < items.size(); i++)

        {

            if (items.at(i) == item)

            {

                // Return true if the element is found.

                return true;

            }

        }

        // Otherwise, return false.

        return false;

    }

    // Define the function to return the size of the list.

    size_t size() const

    {

        return items.size();

    }

    // Define the function to check if the list is

    // empty or not.

    bool empty() const

    {

        return items.empty();

    }

    // Declare the friend functions with template.

    template <class U>

    friend ostream& operator << (ostream& out, const UList<U>& myList);

    template <class U>

    friend void sort (UList <U>&);

};

// Define function to overload the << operator.

template <class U>

ostream& operator << (ostream& out, const UList <U>& myList)

{

    // Start the loop to travese the list.

    for(int i = 0; i < myList.items.size(); i++)

    {

        // Add the value to the object.

        out << myList.items.at(i) << " ";

    }

    // Return the object.

    return out;

}

#endif

sortBS.h

#ifndef SORTBS_H

#define SORTBS_H

// Include the required header files.

#include "UList.h"

// Define the function to sort the list using

// bubble sort.

template <class U>

void sort (UList<U>& myList)

{

    // Start the loop to traverse the list.

    for (int i = 0; i < myList.size()-1; i++)

    {

        for (int j = 0; j < myList.size()-i-1; j++)

        {

            // Check if the values are in order or not.

            if (myList.items.at(j) > myList.items.at(j+1))

            {

                // Use a temporary variable to swap

                // the elements if they are not in order.

                U temp = myList.items.at(j);

                myList.items.at(j) = myList.items.at(j+1);

                myList.items.at(j+1) = temp;

            }

        }

    }

}

#endif

main.cpp

// Include the required header files.

#include <iostream>

#include "UList.h"

#include "sortBS.h"

// Use the standard namespace.

using namespace std;

// Define the main() function.

int main()

{

    // Create an object of the class UList.

    UList<int> myList;

    // Enter few values in the list.

    myList.insert(40);

    myList.insert(20);

    myList.insert(30);

    myList.insert(10);

    // Display the initial list using the << operator.

    cout << "Initial list: ";

    cout << myList << endl;

    // Call the function to sort the list using

    // bubble sort.

    sort(myList);

    // Display the sorted list.

    cout << "Sorted list: ";

    cout << myList << endl;

    // Return 0 and exit the code.

    return 0;

}