1 链表排序
1.1 链表排序
归并排序
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2)
{
struct ListNode *head = new ListNode(0);
struct ListNode *cur = head;
while (l1 && l2)
{
if (l1->val > l2->val)
{
cur->next = l2;
l2 = l2->next;
}
else
{
cur->next = l1;
l1 = l1->next;
}
cur = cur->next;
}
cur->next = l1 ? l1 : l2;
ListNode *newHead = head->next;
delete head;
return newHead;
}
struct ListNode* sortList(struct ListNode* head)
{
if (!head || !head->next)
{
return head;
}
struct ListNode *slow = head, *fast = head, *pre = head;
while (fast && fast->next)
{
pre = slow;
slow = slow->next;
fast = fast->next->next;
}
pre->next = NULL;
return mergeTwoLists(sortList(head), sortList(slow));//slow为原链表的中间节点
}
};
1.2 合并排序列表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergerTwoSortedList2(ListNode *head1, ListNode *head2)
{
if (head1 == NULL)
{
return head2;
}
if (head2 == NULL)
{
return head1;
}
if (head1->val <= head2->val)
{
head1->next = mergerTwoSortedList2(head1->next, head2);
return head1;
}
else
{
head2->next = mergerTwoSortedList2(head1,head2->next);
return head2;
}
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
if (lists.empty())
{
return NULL;
}
ListNode *head = lists[0];
while(lists.size() > 1)
{
head = mergerTwoSortedList2(lists[0], lists[1]);
lists.erase(lists.begin(), lists.begin() + 2);
lists.push_back(head);
}
return head;
}
};
1.3 对链表进行插入排序
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* insertionSortList(ListNode* head) {
ListNode *orderedHead = head;
ListNode *unOrderedHead = head->next;
orderedHead->next = NULL;
ListNode *tmp = orderedHead, *pre = NULL;
while (unOrderedHead)
{
if (tmp)
{
if (tmp->val > unOrderedHead->val)
{
ListNode *next = unOrderedHead->next;
if (pre)
pre->next = unOrderedHead;
else
orderedHead = unOrderedHead;
unOrderedHead->next = tmp;
unOrderedHead = next;
tmp = orderedHead;
pre = NULL;
}
else
{
pre = tmp;
tmp = tmp->next;
}
}
else
{
pre->next = unOrderedHead;
unOrderedHead = unOrderedHead->next;
pre->next->next = NULL;
tmp = orderedHead;
pre = NULL;
}
}
return orderedHead;
}
};
1.4 设计推特
struct Node
{
Node(int v, int s):val(v),seq(s)
{
next = NULL;
}
int val;
int seq;
Node *next;
};
struct List
{
List()
{
head = NULL;
}
Node* insertFront(Node *node)
{
if (!node)
return head;
node->next = head;
head = node;
return head;
}
Node *getHead()
{
return head;
}
static Node *merge(Node *l1, Node *l2)
{
Node *head = new Node(0,0);
Node *cur = head;
while (l1 && l2)
{
if (l1->seq > l2->seq)
{
cur->next = new Node(l1->val, l1->seq);
l1 = l1->next;
}
else
{
cur->next = new Node(l2->val, l2->seq);
l2 = l2->next;
}
cur = cur->next;
}
while (l1)
{
cur->next = new Node(l1->val, l1->seq);
l1 = l1->next;
cur = cur->next;
}
while (l2)
{
cur->next = new Node(l2->val, l2->seq);
l2 = l2->next;
cur = cur->next;
}
return head->next;
}
Node* head;
};
class Twitter {
public:
int seq;
unordered_map<int, List*> userPost;
unordered_map<int, unordered_set<int>> userFollowee;
Twitter() {
seq = 0;
}
void postTweet(int userId, int tweetId) {
if (!userPost.count(userId))
{
List *tmp = new List;
Node *node = new Node(tweetId, ++seq);
tmp->insertFront(node);
userPost[userId] = tmp;
}
else
{
Node *node = new Node(tweetId, ++seq);
userPost[userId]->insertFront(node);
}
}
vector<int> getNewsFeed(int userId) {
Node *list1 = NULL, *head = list1;
if (userPost.count(userId))
{
list1 = userPost[userId]->getHead();
head = list1;
}
for (auto& i : userFollowee[userId])
head = List::merge(head, userPost.count(i) ? userPost[i]->getHead() : NULL);
Node *cur = head;
int k = 10;
vector<int> r;
while (k-- && cur)
{
r.push_back(cur->val);
cur = cur->next;
}
return r;
}
void follow(int followerId, int followeeId) {
userFollowee[followerId].insert(followeeId);
}
void unfollow(int followerId, int followeeId) {
if (userFollowee.count(followerId))
{
userFollowee[followerId].erase(followeeId);
}
}
};
/**
* Your Twitter object will be instantiated and called as such:
* Twitter* obj = new Twitter();
* obj->postTweet(userId,tweetId);
* vector<int> param_2 = obj->getNewsFeed(userId);
* obj->follow(followerId,followeeId);
* obj->unfollow(followerId,followeeId);
*/
1.5
1.6
1.7
2
2.1
2.2
2.3
2.4
3
3.1
3.2
3.3