链表学习

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        
        if(head == NULL)
            return false;

        // Use long long type for 64-bit os
        unordered_set<long long> node_address;

        ListNode* p = head;
        while(p != NULL){
            if(node_address.find((long long)(p)) == node_address.end())
                node_address.insert((long long)(p));
            else
                return true;

            p = p->next;
        }

        return false;
    }
};

合并 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;

        ListNode* dummyHead = new ListNode(-1);
        ListNode* curNode = dummyHead;

        int finished = 0;
        for(ListNode* node: lists)
            if(node == NULL)
                finished ++;

        while(finished < lists.size()){

            ListNode* nextNode = NULL;
            int nextIndex = -1;
            for(int i = 0 ; i < lists.size() ; i ++)
                if(lists[i] != NULL){
                    if(nextIndex == -1 || lists[i]->val < nextNode->val){
                        nextNode = lists[i];
                        nextIndex = i;
                    }
                }
            assert(nextIndex != -1 && nextNode != NULL);

            lists[nextIndex] = lists[nextIndex]->next;
            if(lists[nextIndex] == NULL)
                finished ++;

            curNode->next = nextNode;
            nextNode->next = NULL;
            curNode = curNode->next;
        }

        ListNode* ret = dummyHead->next;
        delete dummyHead;
        return ret;
    }
};