LeetCode 24. Swap Nodes in Pairs
题目描述:
Given a linked list, swap every two adjacent nodes and return its head.
Example:
Given 1->2->3->4, you should return the list as 2->1->4->3.
Note:
Your algorithm should use only constant extra space.
You may not modify the values in the list's nodes, only nodes itself may be changed.
题目理解:
给定一个链表,每两个元素交换一次,最后返回链表的头元素。
要求:算法只能使用常数级别的空间,不能改变链表结点的值,只能通过交换结点的方式调换顺序。
思路:很直观的思路,每两个结点交换一次,因为使用的结构体指针,所以没法进行结点之间的直接交换,必须通过修改next来修改链表的顺序。提交了过后,发现里面有使用0ms解决问题,而我的算法是属于递归调用时间数量级的,需要4ms,比较来说,自己的代码确实有很多没用的地方,需要更精简。
这是原来代码:
/**
* 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) {
ListNode* first = head;
if(!first) return NULL;
ListNode* second = head->next;
if(!second) return head;
ListNode* tmp2 = new ListNode(0);
ListNode* pre = new ListNode(0);
tmp2 = second->next;
second->next = first;
first->next = tmp2;
head = second;
pre = first;
first = first-> next;
if(!first) return head;
second = first-> next;
while(second!=NULL){
ListNode* tmp = new ListNode(0);
tmp = second->next;
second->next = first;
first->next = tmp;
pre->next = second;
pre = first;
first = first-> next;
if(!first) break;
second = first-> next;
}
return head;
}
};
这是精简后的:
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* first = head;
if(!first) return NULL;
ListNode* second = head->next;
if(!second) return head;
ListNode* start = new ListNode(0);
start->next = head;
ListNode* pre = start;
while(second!=NULL){
ListNode* tmp = second->next;
second->next = first;
first->next = tmp;
pre->next = second;
pre = first;
first = first-> next;
if(!first) break;
second = first-> next;
}
return start->next;
}
};
其实就是多生成了一个头结点,让之前第一次的交换也有了规律,当时觉得别扭却怎么也想不到方法整合,还是思维太懒惰了。
这是优秀代码中的递归思想解法:
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if (head==NULL) return NULL;
if (head->next==NULL) return head;
ListNode *tmp=swapPairs(head->next->next);
ListNode *p=head->next;
p->next = head;
head->next = tmp;
return p;
}
};
至于时间复杂度为什么会跟递归一样。具体也没搞明白。。。