Vwwxrf

I have been trying to craft a LinkedList class that should be close to production grade, so please be as critical as possible. I'm hoping you guys can help provide tips and point out mistakes I have made so I can improve on it.

I've deleted the copy/move constructors in an attempt to simplify as I'm not quite ready to consider that level of complexity yet.

The idea is that I could use it similar to this:

LinkedList ll;
ll.insert(42);
ll.insert(55);
ll.print();
ll.reversePrint(); 
ll.reverseIterative();
ll.reverseRecursive();
ll.printNthFromEnd(1);

Thank you in advance for your help.

LinkedList.h

class ListNode 
public:
 int data;
 ListNode* next;
 ListNode(int data);
 ~ListNode();
 ListNode(const ListNode& copy) = delete;
 ListNode(ListNode&& copy) = delete;
 ListNode& operator=(ListNode copy) = delete;
;

class LinkedList 
public:
 ListNode* root = nullptr;
 LinkedList() = default;
 ~LinkedList();
 LinkedList(const LinkedList& copy) = delete;
 LinkedList(LinkedList&& copy) = delete;
 LinkedList& operator=(LinkedList copy) = delete;
 void insert(int data);
 bool isEmpty();
 void print();
 void reversePrint();
 void reversePrintUtil(ListNode* current);
 void reverseIterative();
 void reverseRecursive();
 void reverseRecursiveUtil(ListNode* current);
 void printNthFromEnd(int n);
;

ListNode::ListNode(int data)
 : data(data)
 
ListNode::~ListNode() 
 delete next;


LinkedList::~LinkedList() 
 delete root;

void LinkedList::insert(int data) 
 if (root == nullptr) 
 root = new ListNode(data);
 return;
 
 ListNode* temp = root;
 while (temp->next) 
 temp = temp->next;
 
 temp->next = new ListNode(data);

void LinkedList::print() 
 ListNode* temp = root;
 while (temp) 
 std::cout << temp << 'n';
 temp = temp->next;
 


void LinkedList::reversePrint() 
 if (root == nullptr) return;
 reversePrintUtil(root);


void LinkedList::reversePrintUtil(ListNode* current) 
 if (current == nullptr) return;

 reversePrintUtil(current->next);
 std::cout << current->data << 'n';


void LinkedList::reverseIterative() 
 ListNode* prev = nullptr;
 ListNode* current = root;
 ListNode* next = nullptr;

 while (current) 
 next = current->next;
 current->next = prev;
 prev = current;
 current = next;
 

 root = prev;



void LinkedList::reverseRecursive() 
 if (root == nullptr) return;
 reverseRecursiveUtil(root);


void LinkedList::reverseRecursiveUtil(ListNode* current) 
 if (current->next == nullptr) 
 root = current;
 return;
 

 reverseRecursiveUtil(current->next);
 current->next->next = current;
 current->next = nullptr;



void LinkedList::printNthFromEnd(int n) 
 if (root == nullptr) return;
 ListNode* normal = root;
 ListNode* checker = root;

 int i;
 while (i < n) 
 checker = checker->next;
 ++i;
 

 while (checker->next) 
 normal = normal->next;
 checker = checker->next;
 
 std::cout << normal->data << 'n';


bool LinkedList::isEmpty() 
 return root == nullptr;