Not sure if my insert function does it's job okay.

[Bopaki]

I get zero output when I run my program.

 #include<iostream>
#include<cassert>
using namespace std;

template<class Type>
struct nodeType
{
    Type info;
    nodeType<Type> *link;
};
template<class Type>
class linkedListType
{
 //   friend ostream& operator<<(ostream&, const linkedListType<Type>&);

public:
   const linkedListType<Type>& operator=( const linkedListType<Type>&);
void initializeList();
bool isEmptyList();
int length();
 void destroyList();
 Type front();
 Type back();
bool search(const Type& searchItem);
void insertFirst(const Type& newItem );
void insertLast(const Type& newItem);
void insertNode(const Type& newItem)  ; 
    void insert(const Type& newItem) ;
void deleteNode(const Type& deleteItem);
linkedListType();
linkedListType(const linkedListType<Type>& otherList);
~linkedListType();

//protected:
   int count;
nodeType<Type> *first;
nodeType<Type> *last;

private:
    void copyList(const linkedListType<Type>& otherList);
};
template<class Type>
bool linkedListType<Type>::isEmptyList()
{
    return(first == NULL);
}
template<class Type>
linkedListType<Type>::linkedListType()
{
    first = NULL;
    last = NULL;
    count = 0;
}
template<class Type>
void linkedListType<Type>::destroyList()
{
    nodeType<Type> *temp;
    while(first != NULL)
    {
        temp = first;
        first = first-> link;
        delete temp;
    }
    last = NULL;
    count = 0;
}
template<class Type>
void linkedListType<Type>::initializeList()
{
    destroyList();
    }
template<class Type >
ostream& operator<<(ostream& osObject, const linkedListType<Type>& list)
{
   nodeType<Type> *current;
   current = list.first;
    while(current != NULL)
   {
        osObject<<current->info<<" ";
      current = current->link;
   }
    return osObject;
}
template<class Type >
int linkedListType<Type>::length()
{
    return count;
}
template<class Type >
Type linkedListType<Type>::front()
{
    assert(last != NULL);
    return first->info;
}
template<class Type>
Type linkedListType<Type>::back()
{
    assert(last != NULL);
    return last->info;
}
template<class Type>
bool linkedListType<Type>::search(const Type& searchItem)
{
    nodeType<Type> *current;
    bool found;
    current = first;
    found = false;
    while(current != NULL && !found)
        if(current->info == searchItem)
          found = true;
        else
           current = current->link;
    return found;
}
template<class Type>
void linkedListType<Type>::insertFirst(const Type& newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
   newItem->info = newItem;
    newNode->link = first;
    first = newNode;
    count++;
    if(last == NULL) ;
    last = newNode;
}
template<class Type>
void linkedListType<Type>::insertLast(const Type& newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
    newNode->info = newItem;
    newNode->link = NULL;
    if(first == NULL)
    {
        first = newNode;
        last = newNode; 
        count++;
    }
    else
    last->link = newNode;
    last = newNode;
    count++;
}
template<class Type>
void linkedListType<Type>::insertNode(const Type& newItem)
{
    nodeType<Type> *current;
    nodeType<Type> *trailCurrent;
    nodeType<Type> *newNode;
    bool found;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
    if(first == NULL)
    {
        first = newNode;
        count++;

}
    else
    {
    current = first;
    found = false;
        while(current != NULL && !found)
        if(current->info >= newItem)
        found = true;
        else{
            trailCurrent = current;
        current = current->link;
            
        }
        if(current == first)
        {
        newNode->link = first;
            first = newNode;
            count++;
    }
        else
{
        trailCurrent->link = newNode;
            newNode->link = current;
            count++;
    }
}
}
template<class Type>
void linkedListType<Type>::insert(const Type& newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
    newNode->info = newItem;
    newNode->link = NULL;
    
    count++;

}
template<class Type>
void linkedListType<Type>::deleteNode
(const Type& deleteItem)
{
    nodeType<Type> *current;
    nodeType<Type> *trailCurrent;
    bool found;
    
    if(first == NULL)
        cerr<<"Cannot delete from an empty list.\n";
    else
    {
        if(first->info == deleteItem)
        {
            current = first;
            first = first->link;
            count--;
            if(first == NULL)
                last = NULL;
            delete current;
        }
        else
        {
        found = false;
        trailCurrent = first;
            current = first->link;
            
            while(current != NULL && !found)
            {
                if(current->info != deleteItem)
                {
                    trailCurrent = current;
                    current = current->link;
                }
                else
                    found = true;
            }
            if(found)
            {
            trailCurrent->link = current->link;
                count--;
                if(last == current)
                last = trailCurrent;
                delete current;
        }
        else
            cout<<"Item to be deleted is not in  the list."<<endl;

         }
    }
}
    
template<class Type>
void linkedListType<Type>::copyList (const linkedListType<Type>& otherList)
{
    nodeType<Type> *newNode;
    nodeType<Type> *current;
    if(first != NULL)
        destroyList();
    if(otherList.first == NULL)
    {
        first = NULL;
        last == NULL;
        count = 0;
    }
    else
    {
        current = otherList.first;
        count = otherList.count;
        //Copy the first node
      first = new nodeType<Type>;
      assert(first != NULL);
      first->info = current->info;
      first->link = NULL;
        last = first;
        current = current->link;
        //Copy the remaining list
    while(current != NULL)
    { 
        newNode = new nodeType<Type>;
        assert(newNode != NULL);
        newNode->info = current->info;
        newNode->link = NULL;
            
        last->link = newNode;
        last = newNode;
            
        current = current->link;
            }
    }                 
 }
template<class Type>
linkedListType<Type>::~linkedListType()
{
    destroyList();
    }
template<class Type>
linkedListType<Type>::linkedListType (const linkedListType<Type>& otherList)
{
    first = NULL;
    copyList(otherList);
    }
template<class Type>
const linkedListType<Type>& linkedListType<Type>::operator=(const linkedListType<Type>& otherList)
{
    if(this != &otherList)
       copyList(otherList);
    
     return *this;
}
int main()
{
    linkedListType<int> list1, list2;
    int num;
    cout<<"Enter numbers ending with -999.\n";
    cin >> num;
    while(num != -999)
    {
      list1.insert(num);
        cin>>num;
    }
    cout<<endl;
    cout<<"List1: " <<list1 <<endl;
    list2 = list1;
    cout<<"List2: "<< list2 << endl;
    cout<<"Enter the number to be deleted"<<endl;
   cin >> num;
 //   <<endl; 
    list2.deleteNode(num);
    cout<<"After deleting node: " <<"List2 : " <<endl <<list2 <<endl;
    return 0;
}

[againtry]

I get zero output when I run my program.
331 lines of code has given you no output. And this is the first time you've tested it? This is a joke right?

If you are serious the best thing to do is go back to the last version that ran.

As a tip, a method with more than about 5 or 6 lines of code is not worth debugging. It's far too complicated. It should be re-written.

[jonnin]

insert is no good.
depending on where you want to insert, which, if unsorted, would be at the head to make it efficient, you need to connect the pointers (you set to null in your insert).
so
list is empty, so its pointer is null.
new guy's next = head/main list pointer, not null, to do it as I described. If you want it inserted in order or at the far end, you need more.

looks like this...
null / empty,
insert 3
3 -> null //end of list, which happened to be the empty list pointer, how handy!
insert 7
7->3->null
and so on.