leetcode 排序题目

 Merge k Sorted Lists  Insertion Sort List  Sort List  First Missing Positive  Sort Colors

147. Insertion Sort List

Sort a linked list using insertion sort.使用直接插入排序将一个链表排序。

因为链表只能向后走，所以插入时，从表头向后插入。注意第一次循环pre和cur指向第一个元素，第二次循环pre和cur才有先后顺序，这样才能保证最后一个节点也参与到排序中来。

另外，头指针p每次内循环都需要回到初始位置。

还有，做插入排序与不做插入排序的结尾pre和cur的处理是不一样的

class Solution {public:    ListNode* insertionSortList(ListNode* head) {        ListNode* newHead=new ListNode(0);        ListNode* p=newHead;        newHead->next=head;        ListNode* cur=head;        ListNode* pre=head;//注意这里必须是pre和next的顺序        ListNode* ha=p;        while(cur)        {            if(cur->val<pre->val)            {                pre->next=cur->next;                while(p->next->val<cur->val)                {                    p=p->next;                }                ListNode* temp=p->next;                p->next=cur;                cur->next=temp;                cur=pre->next;                p=ha;//需要让p指针再次指向头指针            }            else{            pre=cur;            cur=cur->next;            }        }        p=newHead->next;        delete newHead;        return p;    }};

148. Sort List

Sort a linked list in O(n log n) time using constant space complexity.

将一个链表排序，要求时间复杂度是O(n log n)，空间复杂度是常数。

class Solution {public:        //使用归并排序        //链表只能使用递归的归并排序方式，首先分解，然后合并    ListNode* sortList(ListNode* head) {        //在开头做递归结束判断        if(!head||!head->next) return head;        //1 分割链表        ListNode* pre,* slow=head,* fast=head;//使用快慢指针找到中间的节点（slow指向它）        while(fast&&fast->next)        {            pre=slow;            slow=slow->next;            fast=fast->next->next;        }        pre->next=nullptr;//两个链表分割        //2 递归分割        ListNode* l1=sortList(head);//递归调用        ListNode* l2=sortList(slow);        //3 合并        return merge(l1,l2);    }    ListNode* merge(ListNode* l1,ListNode* l2){//保证传进来的一定是非空链表        ListNode* newhead=ListNode(0);//定义一个头结点        ListNode* p=newHead;//使用一个指针操作头结点，保存头结点的位置        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 newHead->next;//返回合并之后的链表    }};

41. First Missing Positive

Given an unsorted integer array, find the first missing positive integer.

For example,
Given [1,2,0] return 3,
and [3,4,-1,1] return 2.

Your algorithm should run in O(n) time and uses constant space.

桶排序

class Solution {public:    int firstMissingPositive(vector<int>& nums) {        for(int i=0;i<nums.size();i++)//桶排序        {            while(nums[i]>0&&nums[i]<=nums.size()&&nums[i]!=i+1&&nums[i]!=nums[nums[i]-1])                swap(nums[i],nums[nums[i]-1]);        }        for(int i=0;i<nums.size();i++)        {            if(nums[i]!=i+1)                return i+1;        }        return nums.size()+1;            }};

23. Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

使用优先级队列和堆排序

349. Intersection of Two Arrays

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

Note:

• Each element in the result must be unique.
• The result can be in any order.

350. Intersection of Two Arrays II

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].

Note:

• Each element in the result should appear as many times as it shows in both arrays.
• The result can be in any order.

Follow up:

• What if the given array is already sorted? How would you optimize your algorithm?
• What if nums1's size is small compared to nums2's size? Which algorithm is better?
• What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?