Nsryjdtyk

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;

}