Is this the right way to delete a node? This is how I am deleting a node from a singly linked list. Would this be the most correct way?

void Remove(Node** head, int value)
{
    Node** ptr = head;

    while (*ptr &amp;&amp; (*ptr)-&gt;data != value)
        ptr = &amp;(*ptr)-&gt;next;

    if (*ptr)
    {    
        Node* next = (*ptr)-&gt;next;
        delete *ptr;
        *ptr = next;
    }
}
Comments
This is not really C++.
It is just some C code.
Code Review
Everything @matsjoyce said:

Don't need 'head'
Always use '{}' around sub block statements.

Naming conventions
In C++ it is common convention that names of objects (anything that can have its address taken) begins with a lower case letter (this includes function and method names). So I would rename Remove to remove. This is so it is easier to spot the names of user defined types (which should begin with an upper case letters).
Design
Encapsulation is your friend.
A free function to delete elements from a list is the wrong way to go. You should have created a list class that contains nodes. Then add a member function to delete the node.
Query
By the way, why a singly linked list? That sounds like premature optimization to me. Code is much simpler using a doubly linked list (with a sentinel). Of course you are writing in C so you are probably trying to write optimal code down as close to the metal with no help from language semantics.
Without double indirection
Double indirection is horrible. It is hard to read and hard to use in the code. If you want to pass something that needs to be updated pass a reference to the object. Then it will be updated in the function.
A simple technique for traversing a singly linked list is to use two pointers. A pointer to the current element and a pointer to the previous element. Unlinking the element then becomes a simple assignment to the previous element.
class SinleLinkedList
{
    public:
        void remove(int value)
        {
            remove(head, value);
        }
    private:
        Node*     head;
        void remove(Node*&amp; ptr, int value)
        {
            Node*   prev    = NULL     
            Node*   current = ptr;
    
            while(current &amp;&amp; current-&gt;data != value)
            {
                prev    = current;
                current = prev-&gt;next;
            }
    
            // If current is not NULL then we fell out of the
            // above loop because the != failed so it must be equal
            if (current /*&amp;&amp; current-&gt;data == value*/ )
            {
                // Set the value we are going to update after delete.
                // If prev == NULL its the head, otherwise we update
                // next pointer from the prev element.
                Node*&amp;  result = (prev == nullptr) ? ptr : prev-&gt;next;
                
                // Save the next value.
                // Delete the old node and update.
                Node* next = current-&gt;next;
                delete current;
                result = next;
            }
        }
};