LinkList.h

//Header file for LinkList Class
#ifndef LINKLIST_H
#define LINKLIST_H

//#include "stdafx.h"

#include <iostream>

using namespace std;


template <class T>
class LinkList
{
		private:

		struct ListNode
		 {
			 T value1;
			 struct ListNode *next;
		 };

		ListNode *head;   // List head pointer

		public:
		//***Constructor***
		LinkList();
		LinkList(const LinkList<T> &);
		//***Destructor***
		~LinkList();


		//***LinkList Operations***
		//LinkList& operator=(const LinkList &);
		void appendNode(T);
		void insertNode(T);
		void deleteNode(T);
		T getNodeData();
		T getNext();
		void displayList() const;
		T getHead();
		bool searchList(T);

};

//Implimentation for LinkList

//***Constructor***
template <class T>
LinkList<T>::LinkList()
{
	head = NULL;

	cout<<"LinkList Constructor"<<endl;
}

//***Copy Constructor***
template <class T>
LinkList<T>::LinkList( const LinkList &listObj )
{

	head = NULL;

	ListNode *nodePtr;

	nodePtr = listObj.head;

	while(nodePtr != NULL)
	{
		 appendNode(nodePtr->value1);

		 nodePtr = nodePtr->next;
	}

	cout<<"LinkList Copy Constructor"<<endl;
}

//****Copy assignment Operator***
//template <class T>
//LinkList<T>& LinkList<T> :: operator=(const LinkList<T> &other)
//{
//
//}


//***Destructor***
template <class T>
LinkList<T>::~LinkList()
{
	ListNode *nodePtr;
	ListNode *nextNode;

	nodePtr = head;

	while(nodePtr != NULL)
	{
		nextNode = nodePtr->next;
		delete nodePtr;

		nodePtr = nextNode;
	}

	cout<<"LinkList Destructor"<<endl;
}




//***LinkList Operations***
template <class T>
void LinkList<T>::appendNode(T val1)
{
	ListNode *newNode;
	ListNode *nodePtr;

	//newNode = new ListNode(val1);
   newNode = new ListNode;
   newNode->value1 = val1;
   newNode->next = NULL;
	if (!head)
	{
		head = newNode;
	}
	else
	{
		nodePtr = head;

		while (nodePtr->next)

			nodePtr = nodePtr->next;

		nodePtr->next = newNode;
	}
}

template <class T>
void LinkList<T>::insertNode(T val1)
{
	ListNode *newNode;
	ListNode *nodePtr;
	ListNode *prevNode = NULL;

	//newNode = new ListNode(val1);
   newNode = new ListNode;
   newNode->value1 = val1;
   newNode->next = NULL;

	if (!head)
	{
		head = newNode;
		newNode->next = NULL;
	}
	else
	{
		nodePtr = head;
		prevNode = NULL;

		while(nodePtr != NULL && nodePtr->value1 < val1)
		{
			prevNode = nodePtr;
			nodePtr = nodePtr->next;
		}

		if(prevNode == NULL)
		{
			head = newNode;
			newNode->next = nodePtr;
		}
		else
		{
			prevNode->next = newNode;
			newNode->next = nodePtr;
		}
	}


}

template <class T>
void LinkList<T>::deleteNode(T searchVal)
{
	ListNode *prevNode = NULL;
	ListNode *nodePtr;

	if (!head)
		return;

	if(head->value1 == searchVal)
	{
		nodePtr = head->next;
		delete head;
		head = nodePtr;
	}

	else
	{
		nodePtr = head;

		while(nodePtr != NULL && nodePtr->value1 != searchVal)
		{
			prevNode = nodePtr;
			nodePtr = nodePtr->next;
		}

		if(nodePtr)
		{
			prevNode->next = nodePtr->next;
			delete nodePtr;
		}
	}
}

template <class T>
T LinkList<T>::getNodeData()
{
	ListNode *nodePtr;

		nodePtr = head;

       return(nodePtr->value1);
}

template <class T>
T LinkList<T>::getNext()
{
	ListNode *nodePtr;

		nodePtr = head;

       return(nodePtr->next);
}

template <class T>
void LinkList<T>::displayList() const
{
	int count = 0;

	ListNode *nodePtr;

	nodePtr = head;


	while(nodePtr)
	{

	cout<<"Node index "<<count<<endl;
	cout<<nodePtr->value1<<endl;

	cout<<endl;

	count++;

	nodePtr = nodePtr->next;

	}
}

template <class T>
bool LinkList<T>::searchList(T val1)
{
	ListNode *nodePtr;
	int count = 0;
	nodePtr = head;


		while(nodePtr != NULL && nodePtr->value1 != val1)
		{

			nodePtr = nodePtr->next;
			count++;

			if(nodePtr->value1 == val1)
			{
				cout<<nodePtr->value1<<endl;
				return true;
			}
			else
			{
				return false;
			}
		}
}
#endif