Who deletes the nodes after the list is reversed?

Nobody inside reverseList: it only rewires pointers, so the same nodes are still owned by whoever allocated them. The caller frees the list by walking from the new head and calling delete on each node after saving its next. Deleting a node before reading its next is a use-after-free.

Can I use std::unique_ptr for next instead of a raw pointer?

You can, and the loop becomes auto next = std::move(curr->next); curr->next = std::move(prev); prev = std::move(curr); curr = std::move(next);. Ownership then transfers on every step and the nodes free themselves, but a very long unique_ptr chain is destroyed recursively, which can overflow the stack on its own. Raw pointers are the shape the problem gives you here.

Is there a standard library function that reverses a list?

std::list::reverse() and std::forward_list::reverse() relink a standard list in place in O(n), and std::reverse(v.begin(), v.end()) flips a vector. None of them works on a hand-written ListNode* chain, which is why you reverse the pointers yourself.

Why does the recursive version crash instead of throwing on a long list?

C++ has no stack-overflow exception: when the recursion runs past the thread stack (often 8 MB on Linux), the process gets a segmentation fault. Each frame here is small, so the limit sits far above this problem's 500 nodes, but the loop has no limit at all.

Should I write NULL or nullptr?

nullptr has its own type, std::nullptr_t, so it never converts to an integer and picks the pointer overload in a call. NULL is usually just 0. In C++11 and later use nullptr.

Reverse a Linked List in C++: Iterative and Recursive

reverse_list.cpp

C++ 15.3

Not run yet

+ 7 hidden

Input

head = [3, 6, 9, 12, 15]

Expected

[15, 12, 9, 6, 3]

The old tail 15 becomes the new head, and the old head 3 now ends the list.