List

#pragma once
#include <iostream>
using namespace std;

template <typename T>
struct Node
{
	T key;
	Node *next;
	Node(T Data = 0, Node* NextData = nullptr)
	{
		key = Data;
		next = NextData;
	}
};

/*формирование списка(из файла, случайный, из массива и т.д.),
!ввод!, !вывод!, поиск(!по ключу!, !по номеру! !по порядку!),
добавить(!в голову!, !по индексу!, !после ключа!),
удалить(!голова!, !индекс!, !ключ!), скопировать, !уничтожить список!*/
template <typename T>
struct List {
private:
	Node<T> *head;
	unsigned int size;

	Node<T>* find_Key(int key, const char* mode);

	void add(Node<T> *newNode)
	{
		newNode->next = head;
		head = newNode;
	}

	void del(Node<T> *previous)
	{
		Node<T> *p = previous->next;
		previous->next = p->next;
		delete p;
		size--;
	}

public:

	List()
	{
		head = new Node<T>;
		head->key = 0;
		head->next = 0;
		size = 0;
	}

	~List()
	{
		Node<T> *toDel;
		for (Node<T> *p = head; p != nullptr; )
		{
			toDel = p;
			p = p->next;
			delete toDel;
		}
	}

	Node<T>* find_Index(int index);

	Node<T>* find_Key(int key);


	Node<T>* find_Order(int order);

	bool push_Front(T Data)
	{
		add(new Node<T>(Data));
		size++;
		return true;
	};

	bool push_Index(int index, T Data)
	{
		if (index >= size)
			return false;
		Node<T>* usel = find_Index(index);
		add(usel, new Node<T>(Data));
		size++;
		return true;
	}

	bool push_afterKey(int key, T Data)
	{
		Node<T>* usel = find_Key(key);
		if (usel->key == key)
		{
			add(usel, new Node<T>(Data));
			size++;
			return true;
		}
		else
		{
			return false;
		}
	}

	void del_Front()
	{
		Node<T> *oldHead = head;
		head = head->next;
		delete oldHead;
		size--;
	}

	void del_Index(int index)
	{
		Node<T>* next = find_Index(index + 1);
		if (next == head)
		{
			del_Front();
		}
		else
		{
			del(next);
		}
	}

	void del_Key(T key)
	{
		Node<T>* prevoius = find_Key(key, "RETURN PREVIOUS");
		if(prevoius == nullptr)
		{
			del_Front();
		}
		else
		{
			del(prevoius);
		}
	}

	void print()
	{
		for (Node<T> *p = head; p->next != nullptr; p = p->next)
			cout << p->key << " ";
		cout << endl;
	}

	bool empty()
	{
		return head->next;
	}

 };

 template <typename T>
 Node<T>* List<T>::find_Index(int index)
 {
	 Node<T>* next = head;
	 for (int i = 0; size - i - 1 != index && next != nullptr; i++)
	 {
		 next = next->next;
	 }
	 return next;
 }

 template <typename T>
 Node<T>* List<T>::find_Key(int key)
 {
	 Node<T>* next = head;
	 for (; next != nullptr && next->key != key; next = next->next);
	 return next;
 }

 template <typename T>
 Node<T>* List<T>::find_Key(int key, const char* mode)
 {
	 Node<T>* prevoius = nullptr;
	 Node<T>* next = head;
	 for (; next != nullptr && next->key != key; prevoius = next, next = next->next);
	 return prevoius;
 }

 template <typename T>
 Node<T>* List<T>::find_Order(int order)
 {
	 if (order > size)
		 return nullptr;
	 Node<T>* curent = head;
	 for (int i = 0; i != order; i++)
	 {
		 curent = curent->next;
	 }
	 return curent;
 }