Swap two ListNode* in C++ - c++

Question

Please help, I am totally lost here. This is leetcode problem no. 24, swap nodes in pairs.
I am getting this error in screeshot.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
void recurse(ListNode* head){
if(head!=nullptr and head->next!=nullptr){
auto previous = head, current = head->next;
previous->next = current->next;
current->next = previous->next->next;
previous->next->next = current;
recurse(current);
}
}
public:
ListNode* swapPairs(ListNode* head) {
auto front = new ListNode(0, head);
recurse(front);
return front->next;
}
};

Answer 1

UPD: I add some comments to illustrate the OP's correct solution:
if(head!=nullptr and head->next!=nullptr
and head->next->next!=nullptr){
// p->[c]->[x]->y; swap(c, x); y can be null
auto previous = head, current = head->next;
// p->c->x->y
previous->next = current->next;
// p->x->y; c->x->y
current->next = previous->next->next;
// c->y; p->x->y
previous->next->next = current;
// p->x->c->y
recurse(current);
}
original answer 👇
if(head!=nullptr and head->next!=nullptr){
auto previous = head, current = head->next;
previous->next = current->next; // previous->next = head->next->next
current->next = previous->next->next; // current->next = head->next->next->next
previous->next->next = current;
recurse(current);
}
In this if branch you only checked the head and head->next valid.
However you are attempt to invoke head->next->next->next later. Since head->next->next can be nullptr, your program will stop here.
You can find the right solution in the leetcode platform, and here I only reply on why this code doesn't work.

Answer 2

Thank you tieway59, you were right I just figured it out by myself. I was missing one more validation of head->next->next in if block of recurse function.
Here's my working code :
class Solution {
void recurse(ListNode* head){
if(head!=nullptr and head->next!=nullptr
and head->next->next!=nullptr){
auto previous = head, current = head->next;
previous->next = current->next;
current->next = previous->next->next;
previous->next->next = current;
recurse(current);
}
}
public:
ListNode* swapPairs(ListNode* head){
auto front = new ListNode(0, head);
recurse(front);
return front->next;
}
};

Answer 3

To swap two existent adjacent nodes of a list there is no need to create a new node as you are doing
auto front = new ListNode(0, head);
Otherwise there will be a memory leak.
Instead what you need is to pass a pointer to a node by reference.
There is already standard function std::swap in the C++ library that can be used in your recursion function.
Here is a demonstration program.
#include <iostream>
#include <utility>
#include <functional>
struct ListNode
{
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
void clear( ListNode * &head )
{
while ( head )
{
delete std::exchange( head, head->next );
}
}
void create( ListNode * &head, const int a[], size_t n )
{
clear( head );
for ( ListNode **current = &head; n--; current = &( *current )->next )
{
*current = new ListNode( *a++ );
}
}
std::ostream & display( const ListNode * head, std::ostream &os = std::cout )
{
for ( const ListNode *current = head; current != nullptr; current = current->next )
{
os << current->val << " -> ";
}
return os << "null";
}
void swap( ListNode * &current )
{
if ( current && current->next )
{
ListNode * &next = current->next;
std::swap( current, next );
std::swap( current->next, next->next );
swap( next );
}
}
int main()
{
ListNode *head= nullptr;
const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
create( head, a, sizeof( a ) / sizeof( *a ) );
display( head ) << '\n';
swap( head );
display( head ) << '\n';
clear( head );
}
The program output is
0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> null
1 -> 0 -> 3 -> 2 -> 5 -> 4 -> 7 -> 6 -> 9 -> 8 -> null