Given a linked list, swap every two adjacent nodes and return its head.
For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.
Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.
http://oj.leetcode.com/problems/first-missing-positive/
Solution:
If length is 0 or 1, return head. assume there is ...->node1->node2->node3->..., what we want is ...->node2->node1->node3->...
https://github.com/starcroce/leetcode/blob/master/swap_nodes_in_pairs.cpp
// 24 ms for 55 test cases
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *swapPairs(ListNode *head) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(head == NULL || head->next == NULL){
return head;
}
ListNode *node1 = head;
ListNode *node2 = node1->next;
// prev is the last node of the swapped list
ListNode *prev = NULL;
while(node2 && node2->next){
ListNode *tmp = node2->next;
node2->next = node1;
node1->next = tmp;
// if at the start
if(prev == NULL){
head = node2;
prev = node1;
}
else{
prev->next = node2;
prev = node1;
}
node1 = node1->next;
node2 = node1->next;
}
// length = 2
if(prev == NULL){
head = node2;
node2->next = node1;
node1->next = NULL;
return head;
}
// length is odd
if(node2 == NULL){
return head;
}
// the last swap
node2->next = node1;
node1->next = NULL;
prev->next = node2;
return head;
}
};