The following is coded in C++. Please point out any changes or updates you make to the existing code with comments within the code.

Start with the provided code for the class linkedListType. Be sure to implement search, insert, and delete in support of an unordered list (that code is also provided).

Now, add a new function called insertLast that adds a new item to the END of the list, instead of to the beginning of the list. (Note: the link pointer of the last element of the list is NULL.)

Test your new function in main.

-----------------------------------------------------------------------------------

main.cpp (main driver):

#include 
#include "linkedList.h"
using namespace std;


int main()
{
    linkedListType myLL;
    if(myLL.isEmptyList()){
        cout<<"List is empty"<
----------------------------------------------------------------------

linkedList.h (header file containing declarations):

#ifndef H_LinkedListType
#define H_LinkedListType


#include 
#include 


using namespace std;


//Definition of the node


struct nodeType
{
        int info;
        nodeType *link;
};


//*****************  class linkedListType   ****************


class linkedListType
{
public:
    const linkedListType& operator=
                         (const linkedListType&);
      //Overload the assignment operator.


    void initializeList();
      //Initialize the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    bool isEmptyList() const;
      //Function to determine whether the list is empty.
      //Postcondition: Returns true if the list is empty,
      //               otherwise it returns false.


    void print() const;
      //Function to output the data contained in each node.
      //Postcondition: none


    int length() const;
      //Function to return the number of nodes in the list.
      //Postcondition: The value of count is returned.


    void destroyList();
      //Function to delete all the nodes from the list.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    int front() const;
      //Function to return the first element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the first
      //               element of the list is returned.


    int back() const;
      //Function to return the last element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the last
      //               element of the list is returned.


    bool search(const int& searchItem);
      //Function to determine whether searchItem is in the list.
      //Postcondition: Returns true if searchItem is in the
      //               list, otherwise the value false is
      //               returned.


    void insert(const int& newItem);
      //Function to insert newItem at the beginning of the list.
      //Postcondition: first points to the new list, newItem is
      //               inserted at the beginning of the list,
      //               last points to the last node in the list,
      //               and count is incremented by 1.




    void deleteNode(const int& deleteItem);
      //Function to delete deleteItem from the list.
      //Postcondition: If found, the node containing
      //               deleteItem is deleted from the list.
      //               first points to the first node, last
      //               points to the last node of the updated
      //               list, and count is decremented by 1.




    linkedListType();
      //Default constructor
      //Initializes the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    linkedListType(const linkedListType& otherList);
      //copy constructor


    ~linkedListType();
      //Destructor
      //Deletes all the nodes from the list.
      //Postcondition: The list object is destroyed.


protected:
    int count;   //variable to store the number of
                 //elements in the list
    nodeType *first; //pointer to the first node of the list
    nodeType *last;  //pointer to the last node of the list


private:
    void copyList(const linkedListType& otherList);
      //Function to make a copy of otherList.
      //Postcondition: A copy of otherList is created and
      //               assigned to this list.
};
#endif

------------------------------------------------------

linkedList.cpp (cpp file containing definitions):

#include "linkedList.h"


bool linkedListType::isEmptyList() const
{
    return (first == nullptr);
}


linkedListType::linkedListType() //default constructor
{
    first = nullptr;
    last = nullptr;
    count = 0;
}


void linkedListType::destroyList()
{
    nodeType *temp;   //pointer to deallocate the memory
                            //occupied by the node
    while (first != nullptr)   //while there are nodes in
    {                          //the list
        temp = first;        //set temp to the current node
        first = first->link; //advance first to the next node
        delete temp;   //deallocate the memory occupied by temp
    }
    last = nullptr; //initialize last to nullptr; first has
               //already been set to nullptr by the while loop
    count = 0;
}


void linkedListType::initializeList()
{
        destroyList(); //if the list has any nodes, delete them
}


void linkedListType::print() const
{
    nodeType *current; //pointer to traverse the list


    current = first;    //set current so that it points to
                        //the first node
    while (current != nullptr) //while more data to print
    {
        cout << current->info << " ";
        current = current->link;
    }
}//end print




int linkedListType::length() const
{
    return count;
}  //end length




int linkedListType::front() const
{
    assert(first != nullptr);


    return first->info; //return the info of the first node
}//end front




int linkedListType::back() const
{
    assert(last != nullptr);


    return last->info; //return the info of the last node
}//end back




void linkedListType::copyList(const linkedListType& otherList)
{
    nodeType *newNode; //pointer to create a node
    nodeType *current; //pointer to traverse the list


    if (first != nullptr) //if the list is nonempty, make it empty
       destroyList();


    if (otherList.first == nullptr) //otherList is empty
    {
        first = nullptr;
        last = nullptr;
        count = 0;
    }
    else
    {
        current = otherList.first; //current points to the
                                   //list to be copied
        count = otherList.count;


            //copy the first node
        first = new nodeType;  //create the node


        first->info = current->info; //copy the info
        first->link = nullptr;        //set the link field of
                                   //the node to nullptr
        last = first;              //make last point to the
                                   //first node
        current = current->link;     //make current point to
                                     //the next node


           //copy the remaining list
        while (current != nullptr)
        {
            newNode = new nodeType;  //create a node
            newNode->info = current->info; //copy the info
            newNode->link = nullptr;       //set the link of
                                        //newNode to nullptr
            last->link = newNode;  //attach newNode after last
            last = newNode;        //make last point to
                                   //the actual last node
            current = current->link;   //make current point
                                       //to the next node
        }//end while
    }//end else
}//end copyList


linkedListType::~linkedListType() //destructor
{
   destroyList();
}//end destructor


linkedListType::linkedListType(const linkedListType& otherList)
{
    first = nullptr;
    copyList(otherList);
}//end copy constructor


         //overload the assignment operator
const linkedListType& linkedListType::operator=(const linkedListType& otherList)
{
    if (this != &otherList) //avoid self-copy
    {
        copyList(otherList);
    }//end else


     return *this;
}


bool search(const int& searchItem){}


void insert(const int& newItem){}


void deleteNode(const int& deleteItem){}

-------------------------------------------------------------

Unordered list function implementation file:

bool linkedListType::search(const int& searchItem)
{
    nodeType *current; //pointer to traverse the list
    bool found = false;
    
    current = first; //set current to point to the first 
                     //node in the list


    while (current != nullptr && !found)    //search the list
        if (current->info == searchItem) //searchItem is found
            found = true;
        else
            current = current->link; //make current point to
                                     //the next node
    return found; 
}//end search




void linkedListType::insert(const int& newItem)
{
    nodeType *newNode; //pointer to create the new node


    newNode = new nodeType; //create the new node


    newNode->info = newItem;    //store the new item in the node
    newNode->link = first;      //insert newNode before first
    first = newNode;            //make first point to the
                                //actual first node
    count++;                    //increment count


    if (last == nullptr)   //if the list was empty, newNode is also 
                        //the last node in the list
        last = newNode;
}//end insert (at front)




void linkedListType::deleteNode(const int& deleteItem)
{
    nodeType *current; //pointer to traverse the list
    nodeType *trailCurrent; //pointer just before current
    bool found;


    if (first == nullptr)    //Case 1; the list is empty. 
        cout << "Cannot delete from an empty list."
             << endl;
    else
    {
        if (first->info == deleteItem) //Case 2 
        {
            current = first;
            first = first->link;
            count--;
            if (first == nullptr)    //the list has only one node
                last = nullptr;
            delete current;
        }
        else //search the list for the node with the given info
        {
            found = false;
            trailCurrent = first;  //set trailCurrent to point
                                   //to the first node
            current = first->link; //set current to point to 
                                   //the second node


            while (current != nullptr && !found)
            {
                if (current->info != deleteItem) 
                {
                    trailCurrent = current;
                    current = current-> link;
                }
                else
                    found = true;
            }//end while


            if (found) //Case 3; if found, delete the node
            {
                trailCurrent->link = current->link;
                count--;


                if (last == current)   //node to be deleted 
                                       //was the last node
                    last = trailCurrent; //update the value 
                                         //of last
                delete current;  //delete the node from the list
            }
            else
                cout << "The item to be deleted is not in "
                     << "the list." << endl;
        }//end else
    }//end else
}//end deleteNode

Describe changes in height and weight as well as brain development during the preschool years.

Describe brain development during early childhood.

Describe the influence brain development has on visual skills.

What are the functions of the right and left hemisphere of the brain?

Compare and contrast the neurological function of plasticity during preschool to adulthood.

What are gross motor skills and how do they develop?

Explain how preschoolers acquire gross motor skills.

Describe rough-and-tumble play as well as its role in social skill development.

Compare and contrast physically active parent’s children’s activity level to those children whose parents are inactive. Would you chose to be an active or inactive parent?

Explain the role of drawing and its relationship to the development of motor and cognitive skills.  What are the 4 stages of drawing a picture?

Explain the nutritional needs of the preschool-age child.  Should schools do a better job of providing appropriate nutrition?

Compare and contrast major and minor health issues and illness risks for preschool children.

Explain the sleep needs of preschool children.

Explain sleep patterns during early childhood.

What if any are potential sleep disorders common to early childhood?

In order for true creativity through creative commons to be fully realized, what types of changes do you think we will need to see?

.

1. During the 20^th century, what role did changes in innovation, technology, and communication play:

• in the decline of agriculture’s relative size (in terms of # of jobs) while simultaneously allowing for agricultural production to significantly increase?
• in the decline of manufacturing’s relative size, (in terms of # of jobs) resulting in a fourfold increase in the amount of manufactured goods with only a 20% increase in manufacturing employment?
• growth in the services sector?
• growth in international trade?

Write a paper (750-1,000 words) that analyzes the changes to IMC strategy a company faces in light of the digital upheaval led by Google, Yahoo, Microsoft, and others. The paper should consider Porter’s five forces framework, including competitors, buyers, suppliers, potential entrants, and substitutes.

1. Climate change as a threat to global security?

(Explain the global climate changes, their types and their impact on global security).

2. Ecological migrations?

(How does a country with ecological problems influence the manifestation of ecological migrations? Explain what ecological migrations are)

3. Environmental crime?

(Point out the most important environmental crimes and show the necessary measures and actions in the fight against them)

4. Environmental terrorism ?

(Explain what environmental terrorism is and the measures and actions needed to be taken in the fight against that)

Most of the first portion of our class explored the changes brought about by massive industrialization, urbanization, and immigration during the late nineteenth and early twentieth centuries. Which TWO of these three do you believe are the most important for understanding American history and why

Explore critically the emerging changes in SCM due to coronavirus outbreak in Kazakhstan; discuss the critical importance of efficient transportation, border crossing, warehousing and customer service during the state of emergency in countries; relying on latest analytical data and statistics evaluate the main risks and opportunities that this situation can bring about to our Kazakhstani market and economy from the SCM point of view.

Write an application with three radio buttons labeled “Cyan”, “Magenta”, and “Orange” that changes the background color of a panel in the center of the frame to CYAN, MAGENTA, or ORANGE.

This is required to be programmed in Java.

What problems might be caused by structure changes that are made to implement strategies? Examples? Also, What types of strategies related to changing organization structure might be necessary to implement a strategy? Give examples.