LeetCode-链表

1 链表排序

1.1 链表排序

剑指 Offer II 077. 链表排序

148. 排序链表

归并排序

/**
 * 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 合并排序列表

剑指 Offer II 078. 合并排序链表

23. 合并K个升序链表

/**
 * 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 对链表进行插入排序

147. 对链表进行插入排序

/**
 * 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 设计推特

355. 设计推特

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