Leetcode 21 Merge Two Sorted Lists
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
分析与解法
这个问题没有什么多的解释，直接合并；看代码：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode
4 * {
5 * int val;
6 * ListNode *next;
7 * ListNode(int x) : val(x), next(NULL) {}
8 * };
9 */
10 class Solution
11 {
12 public:
13 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
14 {
15 ListNode dummy(-1);
16 ListNode *p = &dummy;
17 while (l1 && l2)
18 {
19 if (l1->val < l2->val)
20 {
21 p->next = l1;
22 l1 = l1->next;
23 }
24 else
25 {
26 p->next = l2;
27 l2 = l2->next;
28 }
29 p = p->next;
30 }
31 p->next = (l1 != NULL) ? l1 : l2;
32 return dummy.next;
33 }
34 };
Leetcode 23 Merge k Sorted Lists
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
分析与解法
按归并的思路即可。参考代码如下：
1 class Solution
2 {
3 private:
4 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
5 {
6 ListNode dummy(-1);
7 ListNode *p = &dummy;
8 while (l1 && l2)
9 {
10 if (l1->val < l2->val)
11 {
12 p->next = l1;
13 l1 = l1->next;
14 }
15 else
16 {
17 p->next = l2;
18 l2 = l2->next;
19 }
20 p = p->next;
21 }
22 p->next = (l1 != NULL) ? l1 : l2;
23 return dummy.next;
24 }
25 public:
26 ListNode* mergeKLists(vector<ListNode*>& lists)
27 {
28 int n = lists.size(), i, j;
29 if (n == 0) return NULL;
30 while (n > 1)
31 {
32 for (i = 0, j = n-1; i < j; i++, j--)
33 {
34 lists[i] = mergeTwoLists(lists[i], lists[j]);
35 }
36 n = (n+1) / 2;
37 }
38 return lists[0];
39 }
40 };
Leetcode 147 Insertion Sort List
Sort a linked list using insertion sort.
分析与解法
插入排序，参考代码如下：
1 class Solution
2 {
3 public:
4 ListNode* insertionSortList(ListNode* head)
5 {
6 if (!head || !head->next) return head;
7 ListNode dummy(-1); dummy.next = head;
8 ListNode *p = &dummy, *q = head, *pe = head;
9 while (q)
10 {
11 if (q->val >= pe->val)
12 {
13 pe = q;
14 q = q->next;
15 continue;
16 }
17 for (p = &dummy; p->next != q; p = p->next)
18 if (p->next->val > q->val) break;
19 pe->next = q->next;
20 q->next = p->next;
21 p->next = q;
22 q = pe->next;
23 }
24 return dummy.next;
25 }
26 };
Leetcode 148 Sort List
Sort a linked list in O(nlogn) time using constant space complexity.
分析与解法
归并排序思路，递归实现，参考代码如下所示：
1 class Solution
2 {
3 public:
4 ListNode* sortList(ListNode* head)
5 {
6 if (!head || !head->next) return head;
7 ListNode *fast = head, *slow = head;
8 while (fast->next && fast->next->next)
9 {
10 fast = fast->next->next;
11 slow = slow->next;
12 }
13 fast = slow->next;
14 slow->next = NULL;
15 return merge(sortList(head), sortList(fast));
16 }
17 private:
18 ListNode* merge(ListNode *l1, ListNode *l2)
19 {
20 ListNode dummy(0);
21 ListNode *p = &dummy;
22 while (l1 != NULL && l2 != NULL)
23 {
24 if (l1->val < l2->val)
25 {
26 p->next = l1;
27 l1 = l1->next;
28 }
29 else
30 {
31 p->next = l2;
32 l2 = l2->next;
33 }
34 p = p->next;
35 }
36 p->next = (l1 != NULL) ? l1 : l2;
37 return dummy.next;
38 }
39 };
时间： 2024-12-19 08:43:27