You could do it recursively which is a lot neater. The code below is in Java.

void ReversePrint(Node head) {

if(head == null)
    ;
else{
    ReversePrint(head.next);
    System.out.println(head.data);
}

}

Here's what I don't like about these simple problems. The requirements aren't clear. How large is the linked list? Do you want to use recursion on a huge list and blow the stack? Do you have enough memory to create a copy? Do you want to optimize for space complexity or time complexity? Should the solution be non-destructive to the passed in list? (It doesn't help that you're not shown the implementation of the rest of the code). This is a nifty site and a great tool for exercising your programming skills but it absolutely horrifies me that it has become a darling site for IT recruitment. A good programmer isn't a dirty programmer who doesn't think about real world complexities and instead aims for the quickest solution or least number of lines. The emphasis on speed also promotes bad habits in terms of commenting and formatting code.

I used Stack to solve this problem.

java.util.Stack<Node> stack = new java.util.Stack<>();

if(head != null) {
    Node currentNode = head;

    while(currentNode!=null) {
        stack.push(currentNode);
        currentNode = currentNode.next;
    }

    while(!stack.isEmpty()) {
        System.out.println((stack.pop()).data);
    }
}

Neat recursive solution in Python3

def ReversePrint(head):
    if head:
        ReversePrint(head.next)
        print(head.data)

Am I the only crazy person here who didn't even thought of recursion and created another reversed LinkedList just to output the characters in reverse order? :/

void ReversePrint(Node *head)
{
    struct Node* last = NULL;
    while(head != NULL) {
        struct Node* temp = new Node;
        temp->data = head->data;
        temp->next = last;
        last = temp;
        head = head->next;
    }
    
    while(last != NULL) {
        cout<<last->data<<endl;
        last = last->next;
    }
}