[Leetcode Week2]Sort List
Sort List题解
题目来源:https://leetcode.com/problems/sort-list/description/
Description
Sort a linked list in O(n log n) time using constant space complexity.
Solution
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
int partition(vector<int>& arr, int start, int end) {
int pivot = arr[start];
int low = start, high = end;
while (low < high) {
while (arr[low] <= pivot && low < high)
++low;
while (arr[high] > pivot && low < high)
--high;
swap(arr[low], arr[high]);
}
if (arr[low] > pivot)
--low;
arr[start] = arr[low];
arr[low] = pivot;
return low;
}
void quickSort(vector<int>& arr, int start, int end) {
if (start >= end)
return;
int pivotIndex = partition(arr, start, end);
quickSort(arr, start, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, end);
}
ListNode* sortList(ListNode* head) {
if (head == NULL || head -> next == NULL) {
return head;
}
ListNode* temp = head;
vector<int> arr;
while (temp != NULL) {
arr.push_back(temp -> val);
temp = temp -> next;
}
quickSort(arr, 0, arr.size() - 1);
temp = head;
int i = 0;
while (temp != NULL) {
temp -> val = arr[i++];
temp = temp -> next;
}
return head;
}
};
解题描述
这道题考察的是链表排序。我首先想到的是把链表里面的元素拷贝到一个vector里面然后再快排,这就跟平时对数组快排的操作一样了,然后写起来也比较好写。但是AC之后觉得,2次拷贝元素的时间会不会有点多?而且还带来了额外的空间开销。于是自己还是写多了一个针对链表的快排:
class Solution {
public:
void swap(int& a, int& b) {
int t = a;
a = b;
b = t;
}
ListNode* partition(ListNode* low, ListNode* high) {
int key = low -> val;
ListNode *locNode = low; // the location node the that key will locate at last
for (ListNode* tempNode = low -> next; tempNode != high; tempNode = tempNode -> next) {
if (tempNode -> val < key) {
locNode = locNode -> next;
swap(locNode -> val, tempNode -> val);
}
}
swap(low -> val, locNode -> val);
return locNode;
}
void quickSort(ListNode* head, ListNode* tail) {
ListNode* posNode;
if (head != tail && head -> next != tail) { // left close, right open interval
posNode = partition(head, tail);
quickSort(head, posNode);
quickSort(posNode -> next, tail);
}
return;
}
ListNode* sortList(ListNode* head) {
quickSort(head, NULL);
return head;
}
};
但是实际跑出来结果却是(后提交的是用链表快排):
可能因为vector底层是用数组实现的,访问速度会比链表快一些,所以就算加上了拷贝元素的时间,总体的时间复杂度还是要低于直接对链表进行快排。
更优解法
2018.2.3更新
对链表来说,选择归并排序才是更明智的选择
- 链表无法像数组一样快速随机访问元素,要求排序算法元素访问次数较少且稳定
- 使用归并排序处理链表不需要像数组一样使用额外的内存,合并链表的时候只需要进行指针连接即可
下面给出链表递归归并排序的实现:
class Solution {
private:
ListNode* merge(ListNode* head1, ListNode* head2) {
ListNode tempHead(0);
ListNode *curNode = &tempHead;
while (head1 && head2) {
if (head1 -> val <= head2 -> val) {
curNode -> next = head1;
head1 = head1 -> next;
} else {
curNode -> next = head2;
head2 = head2 -> next;
}
curNode = curNode -> next;
}
while (head1) {
curNode -> next = head1;
head1 = head1 -> next;
curNode = curNode -> next;
}
while (head2) {
curNode -> next = head2;
head2 = head2 -> next;
curNode = curNode -> next;
}
return tempHead.next;
}
public:
ListNode* sortList(ListNode* head) {
if (!head)
return NULL;
if (head -> next == NULL)
return head;
if (head -> next -> next == NULL) {
if (head -> val <= head -> next -> val) {
return head;
} else {
ListNode *newHead = head -> next;
newHead -> next = head;
head -> next = NULL;
return newHead;
}
}
ListNode *mid = head, *tail = head;
while (tail && tail -> next) {
mid = mid -> next;
tail = tail -> next -> next;
}
ListNode* head2 = sortList(mid -> next);
mid -> next = NULL;
head = sortList(head);
return merge(head, head2);
}
};