Do I need to delete a dynamically allocated object in Singly Linked List?

Question

I am currently learning Linked Lists and have implemented a singly linked list with Append and Prepend methods where I have allocated objects of type Node on heap using the 'new' operator. Do I need to deallocate the object on heap using 'delete', and if so then how do I do it? Here is my code:-

class List
{
private:
    class Node
    {
    public:
        int data;
        Node* next;
        Node()
        {
            data = 0;
            next = NULL;
        }
        Node(const int& data)
        {
            this->data = data;
        }
    };

    Node* head;
public:
    List()
    {
        head = NULL;
    }
    void Append(const int&val);
    void Prepend(const int&val);
    void DisplayAll();
};

void List::Append(const int&val)
{
    Node* n = new Node(val); //dynamically allocated 
    if (head == NULL)
    {
        head = n;
        return;
    }
    Node* temp = NULL;
    temp = head;
    while (temp->next != NULL)
    {
        temp = temp->next;
    }
    temp->next = n;
}

void List::Prepend(const int&val)
{
    Node* node = new Node(val);//dynamically allocated 
    if (head == NULL)
    {
        head = node;
        return;
    }
    node->next = head;
    head = node;
}

void List::DisplayAll()
{
    Node* temp = head;
    while (temp != NULL)
    {
        std::cout << temp->data << ' ';
        temp = temp->next;
    }
}

Answer 1

For starters this constructor

    Node(const int& data)
    {
        this->data = data;
    }

does not initialize the data member next . As a result member functions Append and Prepend have a bug

void List::Append(const int&val)
{
    Node* n = new Node(val); //dynamically allocated 
    if (head == NULL)
    {
        head = n;
        return;
    }
    //...

and

void List::Prepend(const int&val)
{
    Node* node = new Node(val);//dynamically allocated 
    if (head == NULL)
    {
        head = node;
        return;
    }
    //...

The data member next of the head node has an indeterminate value.

You could declare the class Node simpler like

struct Node
{
    int data;
    Node* next;
};

Node* head = nullptr;

In this case for example the function Prepend will look like

void List::Prepend( const int &val )
{
    head = new Node { val, head };
}

And the constructor will look like

List() = default;

To free all allocated nodes in the list you could write two more member functions clear and the destructor that calls the function clear .

For example

#include <functional>

//...

class List
{
//...
public:
    void clear()
    {
        while ( head ) delete std::exchange( head, head->next );
    }

    ~List() { clear(); }
    //...

Also you should at least either write a copy constructor and the copy assignment operator or define them as deleted.