合并两个有序数组
描述
给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 num1 成为一个有序数组。
说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间(空间大小大于或等于 m + n)来保存 nums2 中的元素。
思路和代码
建议从后往前遍历,因为从前往后遍历会更改元素,要么就要移动元素。
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i = m-1;
int j = n-1;
int p = m+n-1;
while(i>=0 && j>=0)
{
if(nums1[i] >= nums2[j])
nums1[p--] = nums1[i--];
else
nums1[p--] = nums2[j--];
}
while(j >= 0)
{
nums1[p--] = nums2[j--];
}
}
};
合并两个有序链表
描述
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例:
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
思路和代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* dummy = new ListNode(-1);
ListNode* p = dummy;
while(l1 && l2)
{
if(l1->val <= l2->val)
{
p->next = l1;
l1 = l1->next;
}
else
{
p->next = l2;
l2 = l2->next;
}
p = p->next;
}
if(l1)
{
p->next = l1;
}
if(l2)
{
p->next = l2;
}
return dummy->next;
}
};
合并k个排序链表
合并 k 个排序链表,返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
思路和代码
归并的思路
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(lists.size() == 0)
return NULL;
return merge(lists, 0, lists.size()-1);
}
ListNode* merge(vector<ListNode*> &lists, int left, int right)
{
if(left == right)
return lists[left];
int mid = (left+right)/2;
ListNode *l1 = merge(lists, left, mid);
ListNode *l2 = merge(lists, mid+1, right);
return mergerTwoLists(l1, l2);
}
ListNode* mergerTwoLists(ListNode *l1, ListNode *l2)
{
if(l1 == NULL)
return l2;
if(l2 == NULL)
return l1;
if(l1->val < l2->val)
{
l1->next = mergerTwoLists(l1->next, l2);
return l1;
}
else
{
l2->next = mergerTwoLists(l1, l2->next);
return l2;
}
}
};
排序链表
用O(logn)链表排序
class Solution {
public:
ListNode* sortList(ListNode* head) {
if(head == NULL || head->next == NULL)
return head;
//将链表从中间断开,快慢指针
ListNode* fast = head;
ListNode* slow = head;
while(fast->next && fast->next->next){
fast = fast->next->next;
slow = slow->next;
}
fast = slow;
slow = slow->next;
fast->next = NULL;
//排序两个子链表
ListNode* l1 = sortList(head);
ListNode* l2 = sortList(slow);
//两个有序链表合并
return sort(l1, l2);
}
ListNode* sort(ListNode* l1, ListNode* l2)
{
ListNode* dummy = new ListNode(-1);
ListNode* p = dummy;
while(l1 && l2)
{
if(l1->val < l2->val)
{
p->next = l1;
l1 = l1->next;
}
else
{
p->next = l2;
l2 = l2->next;
}
p = p->next;
}
if(l1)
p->next = l1;
if(l2)
p->next = l2;
return dummy->next;
}
};