刷题（未放入）

23. Merge k Sorted Lists

解法一：
每次轮流查找k个链表当前指针的最小值加入到新的链表中，最小值的链表指针向后移位；
假设有k个链表，每个长度为n，那么每次查找最小值O(k)，对每个节点都要查找一次，所以时间复杂度是O(nk^2)。空间复杂度是O（nk）。

解法二：
类似于归并排序，两两结合
第一次合并进行了k/2次，每次2n个节点，第二次进行k/4次，每次4n个节点，以此类推，直到第log(k)次，每次时间复杂度都是O(k n),所以总的时间复杂度是O(knlog(k))。没有用递归。

ListNode* merge2Lists(ListNode* &a,ListNode* &b){
    ListNode *c=new ListNode(0);
    ListNode *curr=c;
    while(a!=NULL&&b!=NULL){
        if(a->val<b->val){
            curr->next=a;
            a=a->next;
            curr=curr->next;
        }
        else{
            curr->next=b;
            b=b->next;
            curr=curr->next;
        }

    }
    if(a!=NULL){.   //这里开始用了while，不需要，直接将当前头节点过来即可
        curr->next=a;
    }
    if(b!=NULL){
        curr->next=b;
    }
    c=c->next;
    curr=c;
    return curr;
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
    if(lists.empty())
        return NULL;
    while(lists.size()>=2){       
        lists.push_back(merge2Lists(lists[0],lists[1]));
        lists.erase(lists.begin());
        lists.erase(lists.begin());
    }
    return lists[0];
}

解法三：
https://www.cnblogs.com/zywscq/p/5403051.html
https://blog.csdn.net/empire_03/article/details/80748638

49. Group Anagrams

解法一
利用map，将排序之后的字符串作为key，所有的相同字母的字符串就是value。

vector<vector<string>> groupAnagrams(vector<string>& strs) {
    map<string,vector<string>> mp;
    map<string,vector<string>>::iterator it;
    vector<string> tmp;
    vector<vector<string>> result;
    for(string str:strs){
        string tmp=str;
        sort(str.begin(),str.end());
        mp[str].push_back(tmp);
    }
    for(it = mp.begin(); it != mp.end(); it++){
        for(string s:it->second){
            tmp.push_back(s);
        }
        cout<<endl;

        result.push_back(tmp);
        tmp.clear();
    }

    return result;

}

解法二
开始考虑到使用数字来对应字母，和相等的就代表相同，但是可能存在不同字符串的和或积相同的情况。参考了网上的代码，用质数就可以比较好的解决这个问题了……